Object lifetime in Java

Introduction

Object lifetime means how long an object exists in a program. It helps us understand when an object is created and when it is removed.

When you want to know how long your data stays in memory.

When you want to manage resources like files or connections safely.

When you want to avoid using objects that no longer exist.

When debugging to find why some objects disappear or stay too long.

Syntax

Java

// Object is created when you use 'new'
ClassName obj = new ClassName();
// Object is destroyed when no references point to it and garbage collector runs

Objects are created using the new keyword.

Java automatically removes objects when they are no longer used, called garbage collection.

Examples

This creates a new object of MyClass and stores it in obj.

Java

MyClass obj = new MyClass();

This removes the reference to the object, so it can be removed by the garbage collector if no other references exist.

Java

obj = null;

Here, localObj is created when the method runs and disappears when the method ends.

Java

public void method() {
    MyClass localObj = new MyClass();
    // localObj exists only inside this method
}

Sample Program

This program creates two objects. One is set to null right after creation, so it can be removed by Java's garbage collector. The other exists until the program ends. The finalize method shows when objects are destroyed (note: it may run later or not at all immediately).

Java

class ObjectLifetimeDemo {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();
        obj1 = null; // obj1 no longer points to the object
        MyClass obj2 = new MyClass();
        // obj2 exists until main ends
        System.out.println("Program finished");
    }
}

class MyClass {
    public MyClass() {
        System.out.println("Object created");
    }
    @Override
    protected void finalize() throws Throwable {
        System.out.println("Object destroyed");
        super.finalize();
    }
}

Important Notes

Java's garbage collector decides when to remove objects; it is not immediate after setting references to null.

The finalize method is called before an object is removed but is not guaranteed to run immediately.

Local objects inside methods exist only while the method runs.

Summary

Objects are created with new and exist while referenced.

When no references point to an object, Java can remove it automatically.

Understanding object lifetime helps manage memory and avoid errors.

Practice

1. Which statement best describes the lifetime of an object in Java?

easy

A. An object exists as long as there is at least one reference to it.

B. An object exists only during the execution of the main method.

C. An object is deleted immediately after it is created.

D. An object exists forever once created, regardless of references.

Solution

1. Step 1: Understand object references in Java

   Objects are created using new and remain in memory while referenced.

2. Step 2: Recognize garbage collection behavior

   When no references point to an object, Java's garbage collector can remove it.

3. Final Answer:

   An object exists as long as there is at least one reference to it. -> Option A

4. Quick Check:

   Object lifetime depends on references [OK]

Hint: Remember: objects live while referenced, else garbage collected [OK]

Common Mistakes:

• Thinking objects exist only during main method
• Believing objects are deleted immediately after creation
• Assuming objects live forever regardless of references

2. Which of the following is the correct way to create a new object in Java?

easy

A. MyClass obj = MyClass();

B. MyClass obj = create MyClass();

C. MyClass obj = new MyClass();

D. MyClass obj = new MyClass;

Solution

1. Step 1: Recall Java object creation syntax

   Objects are created using the new keyword followed by the constructor call with parentheses.

2. Step 2: Check each option's syntax

   MyClass obj = new MyClass(); uses correct syntax: new MyClass();. Options A, C, and D are incorrect due to missing new, wrong keywords, or missing parentheses.

3. Final Answer:

   MyClass obj = new MyClass(); -> Option C

4. Quick Check:

   Use new ClassName() to create objects [OK]

Hint: Use 'new' keyword plus parentheses to create objects [OK]

Common Mistakes:

• Omitting the 'new' keyword
• Forgetting parentheses after class name
• Using incorrect keywords like 'create'

3. What will be the output of the following code?

class Test {
  public static void main(String[] args) {
    Test obj1 = new Test();
    Test obj2 = obj1;
    obj1 = null;
    if (obj2 != null) {
      System.out.println("Object alive");
    } else {
      System.out.println("Object dead");
    }
  }
}

medium

A. Runtime exception

B. Object dead

C. Compilation error

D. Object alive

Solution

1. Step 1: Analyze object references

   Initially, obj1 points to the new object. Then obj2 also points to the same object.

2. Step 2: Check effect of setting obj1 to null

   Setting obj1 to null removes one reference, but obj2 still references the object, so it remains alive.

3. Final Answer:

   Object alive -> Option D

4. Quick Check:

   Object lives while any reference exists [OK]

Hint: Object stays alive if any reference points to it [OK]

Common Mistakes:

• Assuming object is dead after one reference is null
• Confusing references with object existence
• Expecting compilation or runtime errors

4. Identify the error in the following code related to object lifetime:

public class Demo {
  public static void main(String[] args) {
    String s = new String("Hello");
    s = null;
    System.out.println(s.length());
  }
}

medium

A. Compilation error due to missing import

B. NullPointerException at runtime

C. No error, prints length of string

D. Syntax error in object creation

Solution

1. Step 1: Understand object reference and null assignment

   The variable s initially references a String object, then is set to null, removing the reference.

2. Step 2: Analyze method call on null reference

   Calling s.length() when s is null causes a NullPointerException at runtime.

3. Final Answer:

   NullPointerException at runtime -> Option B

4. Quick Check:

   Calling methods on null causes NullPointerException [OK]

Hint: Never call methods on null references [OK]

Common Mistakes:

• Thinking code compiles but runs fine
• Expecting compilation errors instead of runtime
• Ignoring null assignment effect

5. Consider the following code snippet:

class Node {
  Node next;
  int value;
  Node(int v) { value = v; }
}

public class Test {
  public static void main(String[] args) {
    Node a = new Node(1);
    Node b = new Node(2);
    a.next = b;
    b = null;
    // Which objects are eligible for garbage collection here?
  }
}

Which objects are eligible for garbage collection after setting b = null;?

hard

A. No objects are eligible because a still references b through next.

B. Only object b is eligible because b reference is null.

C. Both a and b objects are eligible for garbage collection.

D. Only object a is eligible because b is null.

Solution

1. Step 1: Analyze references to objects

   Variable a references the first Node object. Its next field references the second Node object originally referenced by b.

2. Step 2: Understand effect of setting b to null

   Setting b to null removes one reference to the second Node, but a.next still references it, so it is not eligible for garbage collection.

3. Final Answer:

   No objects are eligible because a still references b through next. -> Option A

4. Quick Check:

   Objects live while any reference exists [OK]

Hint: Check all references, including fields, before assuming garbage collection [OK]

Common Mistakes:

• Assuming null variable means object is collectible
• Ignoring references inside other objects
• Confusing variable nullification with object lifetime