Instantiation
From Suhrid.net Wiki
Contents
Constructors
- Every class - including Abstract classes - MUST have a constructor.
- Constructor chaining is built in. Every class constructor will call its default superclass constructor using super().
- Every constructor as its first statement has a call to this() or super().
- Compiler will only automatically insert call to no-arg super() or this().
- CANNOT call an instance method or access instance variables till the super constructor has run.
- Only Static variables can be accessed as a call to super() or this().
Field Initializers
- Initialization of fields can be done through field declaration statements.
- Declaration of field must occur before its usage in any initializer if it is used on the RHS of an assignment. This will always result in a compiler error. Example:
public class Init4 {
int length = 10;
int area = length * width; //Illegal since width is a forward reference being used on the RHS.
int width = 20;
}
- Initializer expression must not result in an uncaught checked exception. Compiler will throw an error.
public class Init4 {
int length = 10;
int width = 20;
int area = getArea(); //Compiler error - uncaught exception.
private int getArea() throws Exception {
return length * width;
}
}
Initialization Blocks
- A static initialization block runs when the class is first loaded.(Runs only once)
- An instance init block runs every time a new instance is created.
- An instance init block runs right after the call to super() in a constructor (ie. after all the super-constructors have run).
- In case of multiple init blocks (either instance and static) they run in the order in which they are defined.
- An interface CANNOT have any intialization blocks. Only initializer expressions for its static variables.
- Exceptions in init blocks can be handled using try-catch mechanism.
- A java.lang.ExceptionInInitializerError is thrown to indicate that an exception occurred during evaluation of a static initializer block or the initializer for a static variable.
- An instance-init block can result in an uncaught exception - provided that the exception is declared in the throws clause of every constructor.
- In a static - init block this is NOT possible - since there is no constructor invocation to handle the exception. So no uncaught checked exceptions are possible for static initializers.
- Example:
public class Init5 {
private int id;
private static int count = 10;
static {
if(count < 20) {
throw new FileNotFoundException(); //Error
}
}
{
if(id > 0) {
throw new InterruptedException(); //Uncaught checked exception allowed, because constructor declares it.
}
}
Init5(int id) throws InterruptedException {
this.id = id;
}
public static void main(String[] args) {
try {
Init5 i0 = new Init5(0);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
Complete Initialization Order
- Class is initialized only when it is referenced.
- Instance level data is initialized only when an object is constructed.
- Class level initialization takes place before any instance of the class can be created or a static method of the class is invoked.
- Superclass is initialized before its sub class
- All static initializer expressions and static initializer blocks are executed in the order in which they appear. i.e. all static parts of the class hierarchy (starting top-down) are initialized before instance initialization begins.
- Next, all instance fields are initialized to their default values (irrespective of whether they get non-default initial values later or not)
- Constructor is invoked which starts constructor chaining.
- Once all super constructors finish executing, Initialization of the instance fields happens by either initializer expressions or initializer blocks in the order in which they are specified.
- Constructor resumes executing.