Creation of an Object:
Following steps are completed while creating a new object of any class :-
1. Bind Constructor parameters.
2. If explicit this(),call recursively and skip to step 5.
3. Call recursively the implicit and explicit super(...),except for their Object class
because it has no parent class.
4. Execute the explicit instance variable initializers. // it refers to initialisation of instance variables at the time of their declaration.
5. Execute the body of the current constructor.
Exceptions
1.finally clause is always executed regardless of the fact that exception is caused or not.
2.only way that finally will not be executed is virtual machine shutdown or execution of "System.exit(0)" method.
3.If return statement is embedded inside the try block then finally clause executes before return.
4. Exception must be thrown in same line where its object is created because it contains line no. information.
Accessing Members of "super base" Class
Suppose class B extends class A and class C further extends class B.
Now Suppose we want to access the members of class A directly through C class.
This can be either accomplished by using super twice once in C and once in B.
Or other way is to use super in Class C and if members with same name are not
present in B then this super will directly refer to member in super base class A.
example of a such a program.
class A
{
static
{
System.out.println("static initializer of A");
}
{
System.out.println("initializer of A");
}
A()
{
System.out.println("Constructor class A");
}
A(int a)
{
System.out.println("Constructor class A parameter");
}
void hello()
{
System.out.println("Hello in c");
}
void quality()
{
System.out.println("Quality Method Class A");
}
}
class B extends A
{
static
{
System.out.println("static initializer of B");
}
{
System.out.println("initializer of B");
}
B()
{
System.out.println("Constructor class B");
}
B(int b)
{
System.out.println("Constructor class B parameter");
}
void show()
{
System.out.println("I m in class B");
}
}
class C extends B
{
static
{
System.out.println("static initializer of C");
}
{
System.out.println("initializer of C");
}
C()
{
System.out.println("Constructor class C");
}
C(int c)
{
//super.show();
System.out.println("Constructor class C parameter");
}
void show()
{
System.out.println("I m in class C");
}
void quality()
{
super.quality();
System.out.println("Quality Method Class C");
}
}
public class inh
{
public static void main(String ...args)
{
A a=new C(3);
a.quality();
}
}
Polymorphic Arguments in Polymorphism
Suppose a method in a class uses reference of some base class as its argument to perform certain calculations. Now it can also intake the object of child class as its argument because child is also a type of base class object. Bu important point is that this method can only access the members of parent class and not child specific features.
Referring members of a base class in Polymorphism
If we create reference of base class then we can access child class methods which are overridden but child class specific methods are not accessible as accomplished by following program:
class base
{
base()
{
System.out.println("base class");
}
void show()
{
System.out.println("Show method base class");
}
}
class child extends base
{
child()
{
System.out.println("child class");
}
void show()
{
System.out.println("Show method child class");
}
void specific()
{
System.out.println("Specific Method of Child class not present in base");
}
public static void main(String args[])
{
base b=new child();
b.specific();//illegal will not compile
b.show();//child class method executes
}
}