Object Life Cycle in Java

Based on the idea of object-oriented programming, or OOP, Java is a flexible and popular programming language. Everything in Java is an object, and objects go through many stages in their lifetime. In order to ensure proper resource management and program functioning, Java developers need to be aware of the object life cycle. We will examine the object life cycle in Java in depth in this post, going over each stage with examples.

1. Creation (or Instantiation) of Object:

The first stage of an object's life cycle is called generation or instantiation. Objects are instances of classes that serve as the objects' building pieces. To create an object in Java, use the class constructor following the new keyword.

ObjectCreation.java

public class MyClass {
    // Class members and methods
}
public class ObjectCreation {
    public static void main(String[] args) {
        // Creating an object of MyClass
        MyClass myObject = new MyClass();
    }
}

In this case, an instance of the MyClass class is produced by the new MyClass() command, and the reference to this freshly formed object is myObject.

2. Initialization

After an object is formed, it has to be initialised it means that its initial state or values need to be established. Constructors and setter methods are typically utilised for this.

ObjectExample.java

public class Student {
    private String name;
    // Constructor for initialization
    public Student(String studentName) {
        name = studentName;
    }
    public void displayInfo() {
        System.out.println("Student Name: " + name);
    }
}
public class ObjectExample {
    public static void main(String[] args) {
        // Initializing and using the Student object
        Student student = new Student("John Doe");
        student.displayInfo();
    }
}

Here, the Student class has a constructor that takes the student's name as a parameter and initializes the name field. The displayInfo() method then displays the information about the student.

3. Usage:

An object can be used for a variety of purposes after it has been created and initialised. An object interacts with other things and its surroundings throughout this active stage of its life cycle.

ObjectExample.java

// Caluclator class
class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}
// Main class of the program
public class ObjectExample {
    public static void main(String[] args) {
        // creating Calculator object
        Calculator calculator = new Calculator();
        // calling the method
        int result = calculator.add(1, 4);
        System.out.println("Result: " + result);
    }
}

Output:

4. Reference and Dereference

Variables related to objects during the use phase. An object can be made eligible for garbage collection by setting its variable to null after it is no longer needed.

ObjectLifeCycle.java

public class ObjectLifeCycle {
    public static void main(String[] args) {
        // Creating and referencing an object
        MyClass myObject = new MyClass();
        // Dereferencing the object
        myObject = null;
    }
}

When an object is set to null, it indicates that it is no longer referenced, and the Java garbage collector may be able to reclaim the memory it was consuming.

5. Garbage Collection

Garbage collection is an automated memory management mechanism in Java. The garbage collector finds and deletes objects from memory that can no longer be reached or referenced.

ObjectGarbage.java

public class ObjectGarbage {
    public static void main(String[] args) {
        // Creating an object
        MyClass myObject = new MyClass();
        // Making the object eligible for garbage collection
        myObject = null;
        // The garbage collector will reclaim the memory occupied by myObject
    }
}

Here, the myObject is set to null, making it eligible for garbage collection.

6. Finalization

The finalize() method in Java enables an object to carry out cleaning tasks prior to being picked up by garbage collection. It's important to remember, though, that using finalize() is not recommended; instead, try-with-resources or the AutoCloseable interface are preferable resource management techniques.

public class Resource implements AutoCloseable {
    // Resource initialization and usage
    @Override
    public void close() throws Exception {
        // operations
    }
}

Conclusion

It is important to comprehend the Java object life cycle in order to write reliable and effective programmes. Developers may ensure seamless application execution and resource management by understanding the different stages an object goes through. The whole object life cycle that includes instantiation, initialization, usage, reference, dereference, and trash collection controls how objects behave in Java programmes.

Next Topicprint() Vs. println() in Java

← prev next →