6546488 Tips and Tricks for Java

Share Embed Donate

Short Description

Download 6546488 Tips and Tricks for Java...


Tips and Tricks for Java(Useful for Sun Certification)

Main class (filename) cannot be private/protected/static.

Main class has to be public/abstract/final.

Method cannot be Abstract and final at the same time.

Abstract class need not have a single abstract method.

Methods cannot be overridden to be more private.

Final method should not be overridden.

Final object reference variable cannot be changed.

Any number of null elements can be added to Vector/Linked List.

A variable cannot be volatile and final at the same time.???

Methods in an interface cannot be final as they need to be overridden by class implementing the interface. They are public by default.

‘This’ keyword cannot be used with respect to static methods and variables.

Static methods cannot be overridden to be non-static.

Static variables and static initializer blocks are loaded before main.

Top level classes and methods can never be private and abstract at the same time.

Inner class variables cannot be ‘Static’ unless the class itself is declared as ‘Static’.

Inner class can be a subclass of an outer class and can implement interfaces.

In base class if a non-zero argument constructor is provided and it is subclassed without making any call to super(args),compiler creates a call to super().Since there is no default constructor in place compilation fails. e.g : class A { A(int a , int b) {

} class B extends A { B(int a, int b) { //compiler will make an implicit call to super() here since super(a,b) is not


} }

 

Any component size changes from platform to platform. 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

StringBuffer class does not override equals method of the Object class, hence it performs a shallow compare on Object references.

Variables cannot be declared STATIC within any method. This is because lifetime and scope of local variables is restricted to that of the method in which they are declared whereas static variables are class variables and they are loaded when the class is loaded, and exist in memory till the class is unloaded.

Anonymous classes cannot have any constructors.

Garbage collector thread is the least priority thread, and it does “NOT” ensure that the program will not run out of memory.

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.

Non – static methods can call static members of a class.

Writer classes (PrintWriter , FileWriter etc.) are more oriented towards Unicode characters

Finalize() method can be overloaded and made public

Equals () method of Object class by default compares only references to objects.

All method binding in Java uses late binding unless method unless the method is declared FINAL.

An Interface can have a static inner class in its namespace

Inner classes cannot be overridden like methods.

In the derived class constructor one should only call private/final methods of base class.

Comments cannot be nested in Java.

Positive and negative zeroes are EQUAL.

Floating-point operations never throw exceptions.

All arrays in Java are objects. Each is associated with a class, which can be retrieved by getClass() method.

An interface cannot have the same name as any of its enclosing class/interface.

Class Myclass { interface Myclass // Compiler error { ….. } }

Methods in interfaces should NOT be declared static.

Methods in an interface must NOT be declared native/strictfp/synchronized/final, but class implementing the interface can declare the method as native/synchronized/strictfp/final.

Local variables cannot be referenced by ‘this’.

Static inner class is also referred to as “Top-level nested class”

Static method CANNOT have a static inner class.

Public static method() { static class Myclass //compile error { } }

Non-static inner class cannot have static variables unless they are declared FINAL.

Map and Set cannot have duplicate elements.

ToString () method is NEVER called on a NULL.

e.g. : Object o = null; System.out.println(o); will not throw NullPointerException.

Division by 0 on float will NEVER throw ArithmeticException.

Hashcode() method of Object class is Native method and can be overridden.

Fields in an Interface can never be Transient.

An instance of object class can be assigned to any valid class file. E.g. : Object o = String.class is perfectly valid.

Static block cannot make a forward reference to static variables defined after its definition.

A.equals(B) will return true if and only if the 2 objects A and B are of the same class.

Null literal does not have any type, hence it cannot be cast to any other type.

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 }

Initializer blocks are loaded only when object is created.

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 }

Abstract method CANNOT be synchronized.

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.

Lock acquired on the object by a synchronized method is released if the method throws an Exception

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 } }

Constructors can have classes defined in their scope. e.g. : class Myclass { Myclass () { class Constclass () {} } }

Calling a private superclass constructor in the derived class is not allowed.

A thread can be called daemon if and only if the creating thread is daemon.

PrintStream class methods never throw IOException.

Constructors can have empty return statements. e.g. : class A { A ()

{ return; }

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 {} }

Static local class can only access ‘STATIC’ members of enclosing class

An object is eligible for Garbage collection if the only references to the object are from other which are also eligible for GC.

GridBagLayout honours preferred width of a component if Component fill is either NONE or VERTICAL.

Null values cannot be added to a Hashtable.

Thread object set to Null will not stop the thread from execution.

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.

In GridLayout constructor, both rows and columns cannot be simultaneously zero, else RuntimeException is thrown. GridLayout g = new GridLayout(0,0) will throw RuntimeException.

Casting an NAN to an int or long will result in value zero.

Following code will throw an ArraystoreException. Point [] p = new Point [10]; P[0] = new Point ();

Calling yield () in synchronized method or block does NOT relinquish the lock.???

When argument to Math.abs method is of Integer.MIN_VALUE or Long.MIN_VALUE, the value remains the same.

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.

Final static variables can be initialized only in static initializer blocks or during assignment.

Local variables are always thread-safe.

Anonymous class is implicitly final.

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 } }

Local variables which are final CAN remain uninitialized. Void method()

{ final int var; } is perfectly legal

View more...


Copyright ©2017 KUPDF Inc.