object creation in GC

[maggie karve]

Question from ucertify

class BaseClass {  

	int [] numbers={1,2,3,4};
}
public class Numbers{
	public static void main(String[] args){
		Numbers[] num=new Numbers[2];
		num[0]=new Numbers();
		Numbers n=new Numbers();
		num[1]=n;
		n=null;
		num[1]=null;
		
		
	}
}  

how many objects are eligible for Gc..and how many objects are created...
answer is 5 objects are created and 2 are eligible..
i get 4 objects are created............

[Ireneusz Kordal]

I see only 3 objects created:

 Numbers[] num=new Numbers[2]; // 1
		num[0]=new Numbers(); // 1
		Numbers n=new Numbers(); // 1  

Base class is not used in this code, so it is not loaded nor initialised.

But i bet that the author of this question wanted the class Base to be extended by the class Numbers, but he accidentally "lost" the clause 'extends BaseClass'
In this case (Numbers extends BaseClass) 5 objects are created (remember that each array is an instance of Object):

class BaseClass {  

	int [] numbers={1,2,3,4};
}
public class Numbers extends BaseClass{
	public static void main(String[] args){
		Numbers[] num=new Numbers[2]; // 1 object  (array is an Object, elements of array are initialized to nulls)
		num[0]=new Numbers(); // 2 objects: Numbers instance  +  member of Numbers: int [] numbers array
		Numbers n=new Numbers(); // 2 objects: Numbers instance  + member of Numbers: int [] numbers array
		num[1]=n;
		n=null;
		num[1]=null; // 2 objects eligible for GC (Instance on Numbers + instance of int[] )
	}
}     

[Tim McGuire]

The two classes (BaseClass and Numbers) have Class objects (1,2)

the array itself is one object. (3)


then it creates two "new Numbers()" (4,5)
and puts them in the array, replacing the initial values.

n becomes eligible when it is set to null.
num[1] does not become null at this point, but

num[1] becomes eligible when it gets set to null

[saima kanwal]

Ireneusz Kordal wrote:I see only 3 objects created:

 Numbers[] num=new Numbers[2]; // 1
		num[0]=new Numbers(); // 1
		Numbers n=new Numbers(); // 1  

Base class is not used in this code, so it is not loaded nor initialised.

But i bet that the author of this question wanted the class Base to be extended by the class Numbers, but he accidentally "lost" the clause 'extends BaseClass'
In this case (Numbers extends BaseClass) 5 objects are created (remember that each array is an instance of Object):

class BaseClass {  

	int [] numbers={1,2,3,4};
}
public class Numbers extends BaseClass{
	public static void main(String[] args){
		Numbers[] num=new Numbers[2]; // 1 object  (array is an Object, elements of array are initialized to nulls)
		num[0]=new Numbers(); // 2 objects: Numbers instance  +  member of Numbers: int [] numbers array
		Numbers n=new Numbers(); // 2 objects: Numbers instance  + member of Numbers: int [] numbers array
		num[1]=n;
		n=null;
		num[1]=null; // 2 objects eligible for GC (Instance on Numbers + instance of int[] )
	}
}     

If Numbers extends BaseClass , so when new is called on Numbers, at line 9, then 3 objects must be created (instead of two): BaseClass (as Baseclass constructor is invoked being the super class of Numbers),Numbers , and the int array in the Baseclass. so when n is set to null ( at line 11), the same 3 objects must die . Basically, I am confused about the number of objects created when there is a superclass and a subclass; should we consider the superclass as a separate object created when the subclass is instantiated?

Also, one more thing to be cleared: Here in this code , i feel that there is no use of line 12, because the object n is set to null at line 11 , and num[1] points to the same object, so it is already set to null. so i think num[1] = null (line 12)is not sending any objects to GC. am i correct or not??

[Ireneusz Kordal]

saima kanwal wrote:If Numbers extends BaseClass , so when new is called on Numbers, at line 9, then 3 objects must be created (instead of two): BaseClass (as Baseclass constructor is invoked being the super class of Numbers),Numbers , and the int array in the Baseclass. so when n is set to null ( at line 11), the same 3 objects must die .

BaseClass is not an 'Object', it is a 'Class'. Class is created/loaded by the class loader
on the first use of the class, and then lives on the heap until program dies (strictly speaking until class loader that holds reference to this class is unloaded
and garbage collected) ... but there are rather advanced topics and this is not covered by SCJP objectives.
On SCJP they test your knowledge only about 'Objects' creation and destroying.
Javaspec defines the object as: An object is a class instance or an array. - http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.3.1
So - in the context of SCJP questions related to garbage collection - do not count 'classes' as 'objects', because this gives you wrong answers.
There are only 2 objects created:
- instance of class Numbers (created by new Numbers)
- instance of field int [] numbers created during object initialization.

saima kanwal wrote:Basically, I am confused about the number of objects created when there is a superclass and a subclass; should we consider the superclass as a separate object created when the subclass is instantiated?

You must know class instance initialization sequence.
Class instance initialization order is as follows:
1. if the class has an ancestor class (extends from base class) - first initialize the ancestor (base) class
(if base class has it's own ancestor - then the ancestor is initialized first ... and so on, and so on).
2. Initialize all field declarations (in the order they are declared in the class declaration).
3. Call all initialization blocks (in the order they are declared in the class declaration).
4. Call the class' constructor.

Look at this example:

class A{
    Integer a1;
    Integer a2 = new Integer(2);   // 1
    Integer a3;
    A(){
        a1 = new Integer(1);      // 3
    }

    {   a3 = new Integer(3);    } // 2
}

class B extends A {
    Integer [] b1;

    {     b1 = new Integer[10];    }  // 5

    Integer b2;
    Integer b3  = new Integer(3);    // 4
    B(){
        b2 = new Integer(1);        // 6
    }
}

class C extends B {
    Integer c1 = new Integer(1);   // 7
    Integer [] c2;

      {   c3 = c2;   }

    Integer [] c3;

    C(){
        c2 = new Integer[]{2, 4, 6};      // 8, 9, 10, 11
    }
}

public class Main {
    public static void main( String [] args ){
        C obj = new C();  // 12
        if( obj.c3 == null ){
            System.out.println(" c3 is null ?????");
        }
        else{
            System.out.println(" c3 has " + obj.c3.length + " elements.");
        }
        obj.c2 = null; // is array Integer[]{2, 4, 6} eligible for GC or not ?
     }
}    

The code above creates 12 objects on the heap.
- in line 39 we instatiate object of class C with new C()
- C extends from B - so first initialize B
- B extends from A - so first initialize A
- A extends from Object (class Object is the ancestor of all java classes) - then first initialize Object
- in A - initialize all fields (if there is no explicit initializer declaration, assign null to the field)
- a1 = null
- a2 = new Integer(2) .... object 1 created !
- a3 = null
- in A - call all initialization blocks - there s only one initialization block in line 9, and in this block object no 2 is created and reference to this object is assigned to the a3 field
- in A - call constructor: in the constructor object no 3 is created, reference is assigned to a3
- A is initialized - continue initialization of B:
- in B: initialize all fields ..... b3 = new Integer()
- in B: call all initialization blocks ..... b1 = new Integer()
- in B: call constructor ..... b2 = new Integer(1)
- B is initialized - continue initialization of C
- in C: initialize all fields ... c1 = new Integer(1)
- in C: call all initialization blocks ... c3 = c2
- in C: call constructor: c2 = new Integer[]{2, 4, 6} ... here 4 objects are created!!! array itself, then 3 objects of Integer !!!
- C is initialized - return to the main block
- main: store reference of the new object C into the obj variable.

But ... there is only ONE object - instance of class C (despite of the fact that there are 4 classes involved: C extends from B, B extends from A and A extends from Object)

There are 2 tricks in this example you must be familiar with ... because you could met them on the exam.
First the declaration:
int [] num = new int[]{1,2,3} creates only ONE object on the heap (one array object)
but
Integer [] num = new Integer[]{1,2,3} creates FOUR objects - an array object plus 3 Integer instances (1,2,3 primitives are automatically autoboxed into Integer)

Second is related to the knowledge of the order of the object instance initialization order:
in line 28 value (reference) from c2 is stored to c3, however after line 46 the object referenced by c2 is eligible for GC;
the pitfall is that line 28 is executed before constructor in line 33, therefore c3 = null.

saima kanwal wrote:
Also, one more thing to be cleared: Here in this code , i feel that there is no use of line 12, because the object n is set to null at line 11 , and num[1] points to the same object, so it is already set to null. so i think num[1] = null (line 12)is not sending any objects to GC. am i correct or not??

n and num[1] are only references to the object ... there are something like pointers in C/C++ or address to the memory space where the object
is allocated (in fact the reference is not the 'true' address, but an index to the JVM internal table that stores memory addresses and other internal informations about objects).
So if you store null in reference variable 'n', this does not change value of of other variables that hold the same reference
... when you assign null to 'n', num[1] still holds reference to the object.

I hope this helps

[Tim McGuire]

BaseClass is not an 'Object', it is a 'Class'. Class is created/loaded by the class loader
on the first use of the class, and then lives on the heap until program dies (strictly speaking until class loader that holds reference to this class is unloaded
and garbage collected) ... but there are rather advanced topics and this is not covered by SCJP objectives.
On SCJP they test your knowledge only about 'Objects' creation and destroying.
Javaspec defines the object as: An object is a class instance or an array. - http://java.sun.com/docs/books/jls/third_edition/html/typesValues.html#4.3.1
So - in the context of SCJP questions related to garbage collection - do not count 'classes' as 'objects', because this gives you wrong answers.

This helped clear it up. Thank you. I was confused because I could use BaseClass.getClass(); and get a value, which made me think that there was an object of type Class there, but the java spec seems pretty clear that we should not be counting those as objects.

[saima kanwal]

@ Ireneusz Kordal: thanks for your explanation. it really helped me. but there is still one confusion, when you instantiate an object, its super constructor is invoked which means that the super class's members are not only initialized but it is intantiated (because of the call super() ); am i correct or not ??

[rushikesh sawant]

when object is created using new keyword:

All instance variables are assigned their DEFAULT values (0,0.0,flase,null etc.)
Then constructor is invoked, which immediately invokes super class constructor.
All super class constructors complete.
Then instance variables which are assigned default values are assigned their INITIAL values.
Then only constructor of that particular class completes.

[Andre Enimot]

Look at this example:

class A{
    Integer a1;
    Integer a2 = new Integer(2);   // 1
    Integer a3;
    A(){
        a1 = new Integer(1);      // 3
    }

    {   a3 = new Integer(3);    } // 2
}

class B extends A {
    Integer [] b1;

    {     b1 = new Integer[10];    }  // 5

    Integer b2;
    Integer b3  = new Integer(3);    // 4
    B(){
        b2 = new Integer(1);        // 6
    }
}

class C extends B {
    Integer c1 = new Integer(1);   // 7
    Integer [] c2;

      {   c3 = c2;   }

    Integer [] c3;

    C(){
        c2 = new Integer[]{2, 4, 6};      // 8, 9, 10, 11
    }
}

public class Main {
    public static void main( String [] args ){
        C obj = new C();  // 12
        if( obj.c3 == null ){
            System.out.println(" c3 is null ?????");
        }
        else{
            System.out.println(" c3 has " + obj.c3.length + " elements.");
        }
        obj.c2 = null; // is array Integer[]{2, 4, 6} eligible for GC or not ?
     }
}    

Hey, isn't array referenced by b1 in line 15 is created BEFORE Integer b3 in line 18?

[thanvi janu]

Very useful..

Thanks,
Thanvi.