Life Cycle of an Object in Java

In Java, objects play the pivotal role; so understanding its instantiation, and how and when it gets garbage collected is important. This post covers the life cycle of objects inside Java Virtual Machine. But keep in mind that, successful creation of the object is possible only if class is already loaded in JVM (by class loader).

Object Creation 

Class instantiation activity gives life to an object and thereafter you can call its methods to manipulate states/attributes. Object creation is done by Java Virtual Machine(after class has been loaded). When JVM creates a new instance of a class, it allocates memory on the heap to hold the object's instance. Memory is allocated for all variables/attributes declared in object's class and in all its superclasses (including hidden attributes). Once the virtual machine has allocated memory for the new object, the machine initializes the instance variable to default initial values. After this VM gives proper initial value depending on how the object gets created:

   1.  new keyword

        Person p = new Person();

        String s = new String("life");

        This is one of the most frequently used approach to create an instance of a class. 

   2.  newInstance() on a Class / Reflection

        Class class = Class.forName("fully.qualified.class.name");

        Object obj = class.newInstance();

        Person p = (Person)obj;

         

        Refer to the detailed Reflection tutorial. 

   3. Cloning         
       Person pClone = (Person)p.clone(); 

       Make sure that, Person class implements Cloneable interface and also provides the definition of the clone() method. 

Refer to the detailed cloning tutorial.

   4. Deserialization      
       FileInputStream fis = new FileInputStream("person.ser");

       ObjectInputStream ois = new ObjectInputStream(fis);

       Person per =(Person)ois.readObject(); 

      

       Deserialization is a technique to convert the encoded byte stream into the corresponding object as 

       shown above. Refer to the detailed tutorial.

   5. Implicit Instantiation

       All above techniques explicitly creates an object of a class. Apart from above, there are multiple implicit ways of object creation as well :

          

       1. Class loading : For every type that a JVM loads, it implicitly creates a new Class object to                  represent that type.

       2. String Literals : When JVM loads a class which has String literals (i.e. String PI = "3.14"), 

           it might create a new String object. 

       3. Expression Evaluation : Process of evaluation an expression like String concatenation

           can also create new objects. 

               

 So above explicit/implicit object instantiation techniques give proper initial value to the object. JVM uses one of the three techniques to do this task, depending on how the object is being created.

If the object is being created because of a clone() invocation, the virtual machine copies the values of the instance variables of the object being cloned into the new object. If the object is deserialized via a readObject() invocation on an ObjectInputStream, the virtual machine initializes non-transient instance object variables from values read from the input stream. Otherwise, the virtual machine invokes an instance initialization method on the object. The instance initialization method initializes the object's instance variables to their proper initial value. 

The Java compiler generates at least one instance initialization method for every class it compiles. In the  Java class file, the instance initialization method is called "<init>". For each constructor in the source code of a class, the Java compiler generates one <init>() method.  

Source : Inside Java 2 Virtual Machine (Lifetime of a type)

Object in action

Once object is created successfully, its ready for the real action.
obj.haveFun();

Garbage Collection of Object / End of life

Application can allocate memory for object via explicit and implicit ways described under object creation, but they can not explicitly free that memory. To signal to JVM that an object is ready for garbage collection, object needs to get unrefrenced in either of below ways :

1. Explicit unreferencing

    person = null;  //person is an instance of Person   

2. Object goes out of scope

    An Object created inside a method goes out of scope once method returns to the calling method.

    So in below case once method() is over, p implicitly becomes null. 

    public void method(){

       Person p = new Person();

       //method action

    } 

   After unrefrencing, VM can reclaim that memory. Virtual machine can decide when to garbage collect unrefrenced object. But specification doesn't guarantee any predictable behavior. It is up-to the VM to decide when to reclaim memory from unrefrenced object or it might NOT reclaim memory at all.

If the class declares a finalizer (i.e. public void finalize() method ) then Garbage Collector will execute the finalize() method on the instance of the class before it frees the memory space occupied by that instance. So clearly, exact time of garbage collection is unpredictable.

Related Article:
how-garbage-collection-works
class-loading-and-unloading-in-jvm
jvm-architecture.html