1)
Main class (filename) cannot
be private/protected/static.
2)
Main class has to be public/abstract/final.
3)
Method cannot be Abstract and final at the same time.
4)
Abstract class need not have a single abstract method.
5)
Methods cannot be overridden to be more private.
6)
Final method should not be overridden.
7)
Final
object
reference variable cannot be changed.
8)
Any number of null
elements can
be added to Vector/Linked List.
9)
A variable cannot be volatile
and final at the same time.???
10)
Methods in an interface cannot be final as they need to be overridden by class implementing the interface.
They are public by default.
11)
‘This’ keyword cannot be used
with respect to static methods and variables.
12)
Static methods cannot be overridden to be non-static.
13)
Static variables and static initializer blocks are loaded before main.
14)
Top level classes and methods can never be private and abstract at the same time.
15)
Inner class variables cannot be ‘Static’ unless the class itself is declared as ‘Static’.
16)
Inner class can be a subclass of an outer class and can implement
interfaces.
17)
Any component size changes from platform to platform.
18)
It is not necessary that if finalize() method is invoked the object will be garbage collected, also it is not
absolutely necessary for it to perform clean-up operations
19)
String Buffer class does not override equals method of the Object class, hence it performs a shallow compare on Object references.
20)
Variables cannot be declared STATIC within any method. This is because
lifetime and scope of local
21)
variables is restricted to that of the method in which they are
declared whereas static variables are
22)
class variables and they are loaded when the class is loaded, and
exist in memory till the class is unloaded.
23)
Anonymous classes cannot have any constructors.
24)
Garbage collector thread is the least priority thread, and it does
“NOT” ensure that the program will not run out of memory.
25)
Variable Assignment is allowed during creation of an array. e.g. :
int I = 4;
int a[] [] [] = new int [I] [I=3][I] ;
is perfectly legal.
26)
Non – static methods can call static members of a class.
27)
Writer classes (PrintWriter , FileWriter etc.) are more oriented
towards Unicode characters
28)
Finalize() method can be overloaded and made public
29)
Equals () method of Object class by default compares only references
to objects.
30)
All method binding in Java uses late binding unless method unless the
method is declared FINAL.
31)
An Interface can have a static inner class in its namespace
32)
Inner classes cannot
be
overridden like methods.
33)
In the derived class constructor one should only call private/final
methods of base class.
34)
Comments cannot be nested in Java.
35)
Positive and negative zeroes are EQUAL.
36)
Floating-point operations never throw exceptions.
37)
All arrays in Java are objects. Each is associated with a class, which
can be retrieved by getClass()
method.
38)
An interface cannot have the same name as any of its enclosing
class/interface.
Class Myclass {
interface Myclass // Compiler error
{ ….. }
}
39)
Methods in interfaces should NOT be declared static.
40)
Methods in an interface must NOT be declared
native/strictfp/synchronized/final, but class
41)
implementing the interface can declare the method as
native/synchronized/strictfp/final.
42)
Local
variables cannot
be referenced by ‘this’.
43)
Static inner class is also referred to as “Top-level nested class”
44)
Static method CANNOT have a static inner class.
Public static method() {
static class Myclass //compile error
{
}
}
45)
Non-static
inner class
cannot have static variables unless they are
declared FINAL.
46)
Map and Set cannot have duplicate elements.
47)
ToString () method is NEVER called on a NULL.
e.g. : Object o = null;
System.out.println(o);
will not throw NullPointerException.
48)
Division by 0 on float will NEVER throw ArithmeticException.
49)
Hashcode() method of Object class is Native method and can be overridden.
50)
Fields in an Interface can never be Transient.
51)
An instance of object class can be assigned to any valid class file.
E.g. : Object o = String.class is perfectly
valid.
52)
Static block cannot make a forward reference to static
variables defined after its definition.
53)
A.equals(B) will return true if and only if the 2 objects A and B are
of the same class.
54)
Null literal does not have any type, hence it cannot be cast to any
other type.
55)
Blank final variables have to be initialized. If they are class
members, they can be initialized only in initializer blocks/constructors.
E.g.:
Class A
{
final int var;
{
var = 10;
} // Initializer block
}
56)
Initializer blocks are loaded only when object is created.
57)
Keywords like this/super CANNOT be used in initializer expressions of
class Variables.
e.g. :
class A
{
int a = 10;
}
class B extends A
{
static int a = super.a; // COMPILE ERROR
}
58)
Abstract method CANNOT be synchronized.
59)
Method declaring a non-void return type in its
header may not provide a return statement in its body
if it declares to throw an
Exception.
e.g :
int method ()
{
throw new RuntimeException();
}
OR
Int method () throws Exception
{
throw new Exception();
}
are valid.
60)
Lock acquired on the object by a synchronized method is released if
the method throws an Exception
61)
If an instance initializer block throws a checked Exception during its
execution, which it does not catch, then the Exception must be declared in the
throws clause of every constructor of the class.
e.g. :
class Test
{
{
if(true) throw new Exception();
}
Test () throws Exception
{ }
Test (int a) throws Exception
{ }
There can be no statement in a method body after
a throw statement.
e.g. :
class NewClass
{
private void method () throws Exception
{
throw new Exception();
return; // COMPILE error Statement not reachable
}
}
62)
Constructors can have classes
defined in
their scope.
e.g. :
class Myclass
{
Myclass ()
{
class Constclass ()
{}
}
}
63)
Calling a private superclass constructor in
the derived class is not allowed.
64)
A thread can be called daemon if and only if the creating thread is
daemon.
65)
PrintStream class methods never throw IOException.
66)
Constructors can have empty return statements.
e.g. :
class A
{
A ()
{
return;
}
67)
Local class is implicitly STATIC if it is defined in static method/
static initializer.
e.g. :
private static void method ()
{
class Innclass
{}
}
is legal and Innclass is implicitly static.But it
should NOT be explicitly prefixed with static keyword.
private static void method ()
{
static class Innclass //COMPILE ERROR
{}
}
68)
Static local class can only access ‘STATIC’ members of enclosing class
69)
An object is eligible for Garbage collection if the only references to
the object are from other which are also eligible for GC.
70)
GridBagLayout honours preferred width of a component if Component fill
is either NONE or VERTICAL.
71)
Null values cannot be added to a Hashtable.
72)
Thread object set to Null will not stop the thread from execution.
73)
If a method declares to throw a checked Exception, it must be caught
by the catch block of the Exception or a superclass of the Exception. Peer
class of Exception in the catch block does not satisfy the requirement and will
flag a compiler error.
74)
In GridLayout constructor, both rows and columns cannot be
simultaneously zero, else RuntimeException is thrown.
75)
GridLayout g = new GridLayout(0,0) will throw RuntimeException.
76)
Casting an NAN to an int or long will result in value zero.
77)
Following code will throw an ArraystoreException.
Point [] p = new Point [10];
P[0] = new Point ();
78)
Calling yield () in synchronized method or
block does NOT relinquish the lock.???
79)
When argument to Math.abs
method is of
Integer.MIN_VALUE or Long.MIN_VALUE, the value remains the same.
80)
Accessing elements of an uninitialized array will cause NullPointerException to be thrown.
e.g. :
int a[] = new int[10];
System.out.println (a[0]);
//NullPointerException.
81)
Final
static variables
can be initialized only in static
initializer
blocks or during assignment.
82)
Local variables are always thread-safe.
83)
Anonymous class is implicitly final.
84)
Abstract method in superclass cannot be accessed in the subclass using
super.
e.g. :
abstract class A
{
abstract void method () ;
}
class B extends A
{
public void method()
{
super.method(); // COMPILER ERROR
}
}
85)
Local variables which are final CAN remain uninitialized.
Void method()
{
final int var;
}
is perfectly legal
