Object lifecycle in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Java code involving object creation and garbage collection?

Consider the following Java code snippet. What will be printed when it runs?

Java

public class Test {
    public static void main(String[] args) {
        Test obj = new Test();
        obj = null;
        System.gc();
        System.out.println("End of main");
    }
    protected void finalize() throws Throwable {
        System.out.println("Finalize called");
    }
}

A End of main

B End of main\nFinalize called

C Finalize called\nEnd of main

D No output

💡 Hint

Garbage collection in Java is not guaranteed to run immediately after System.gc().

The finalize() method may not be called immediately or at all before the program ends. The output will always print "End of main". "Finalize called" is not guaranteed.

❓ Predict Output

intermediate

What is the output when creating multiple objects and nullifying references?

What will be printed by this Java program?

Java

public class Demo {
    static int count = 0;
    Demo() {
        count++;
    }
    public static void main(String[] args) {
        Demo a = new Demo();
        Demo b = new Demo();
        a = null;
        System.gc();
        System.out.println(count);
    }
}

A 2

B 1

C 0

D Compilation error

💡 Hint

Count increments on each object creation, not on garbage collection.

Two objects are created, so count is 2. Nullifying a and calling System.gc() does not reduce count.

🔧 Debug

advanced

Identify the error in this Java object lifecycle code

What error will this code produce when compiled or run?

Java

public class Sample {
    public void finalize() throws Throwable {
        System.out.println("Cleaning up");
    }
    public static void main(String[] args) {
        Sample s = new Sample();
        s = null;
        System.gc();
    }
}

A No error, prints "Cleaning up"

B Compile-time error: finalize() must throw Throwable

C No output, program ends silently

D Runtime error: finalize() not found

💡 Hint

Check the signature of the finalize() method in Java.

The finalize() method is deprecated but still valid with this signature. It may not be called before program ends, so no output is guaranteed.

📝 Syntax

advanced

Which option correctly overrides the finalize method in Java?

Choose the correct method signature to override finalize() in Java.

A private void finalize() throws Throwable

B public void finalize()

C void finalize() throws Exception

D protected void finalize() throws Throwable

💡 Hint

The finalize() method must have a specific signature to override properly.

The correct signature is protected void finalize() throws Throwable. Other options have wrong access modifiers or exception types.

🚀 Application

expert

How many objects are eligible for garbage collection after this code runs?

Given the following Java code, how many objects are eligible for garbage collection after the last line executes?

Java

public class Node {
    Node next;
    public static void main(String[] args) {
        Node a = new Node();
        Node b = new Node();
        Node c = new Node();
        a.next = b;
        b.next = c;
        c.next = a;
        a = null;
        b = null;
    }
}

A 3

B 0

C 1

D 2

💡 Hint

Consider the references and the circular links between objects.

Even though a and b are set to null, the three Node objects reference each other in a cycle, so none are eligible for garbage collection.

Practice

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

easy

A. Objects must be manually deleted to free memory.

B. An object is created automatically without new and never gets removed.

C. Objects live forever once created.

D. An object is created with new and exists as long as it has references.

Solution

1. Step 1: Understand object creation

   In Java, objects are created using the new keyword which allocates memory.

2. Step 2: Understand object lifetime

   An object remains alive as long as there is at least one reference pointing to it. When no references remain, it becomes eligible for garbage collection.

3. Final Answer:

   An object is created with new and exists as long as it has references. -> Option D

4. Quick Check:

   Object lifecycle = created with new and referenced [OK]

Hint: Objects live only while referenced, created with new [OK]

Common Mistakes:

• Thinking objects live forever
• Believing manual deletion is needed
• Assuming objects are created without new

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

easy

A. Car myCar = Car();

B. Car myCar = new Car();

C. new Car myCar();

D. Car myCar = create Car();

Solution

1. Step 1: Recall Java object creation syntax

   In Java, to create an object, use the syntax: ClassName variable = new ClassName();

2. Step 2: Match options with correct syntax

   Car myCar = new Car(); matches the correct syntax. Other options have syntax errors or invalid keywords.

3. Final Answer:

   Car myCar = new Car(); -> Option B

4. Quick Check:

   Use new keyword to create objects [OK]

Hint: Use 'new' keyword with class name and parentheses [OK]

Common Mistakes:

• Omitting 'new' keyword
• Incorrect order of keywords
• Using invalid method-like syntax

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

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

medium

A. Object is alive

B. Object is gone

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Analyze object references

   Initially, obj1 points to a new Demo object. Then obj2 is assigned the same reference as obj1.

2. Step 2: Check null assignment and condition

   obj1 is set to null, but obj2 still references the object. The if condition checks obj2 != null, which is true.

3. Final Answer:

   Object is alive -> Option A

4. Quick Check:

   Object lives while referenced = true [OK]

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

Common Mistakes:

• Assuming object is gone when one reference is null
• Confusing reference variables with objects
• Expecting compilation or runtime errors

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

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

medium

A. Compilation error due to null assignment

B. No error, prints length of string

C. NullPointerException at runtime

D. String object is not created

Solution

1. Step 1: Understand object reference and null assignment

   The variable s initially references a String object. Then it is set to null, so it no longer points to any object.

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 C

4. Quick Check:

   Calling method on null reference causes exception [OK]

Hint: Don't call methods on null references [OK]

Common Mistakes:

• Thinking null assignment causes compile error
• Expecting output instead of exception
• Ignoring null pointer risks

5. Consider the following code snippet:

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

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 nodes are eligible for garbage collection here?
    }
}

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

hard

A. Neither a nor b nodes are eligible

B. Only the node originally referenced by b is eligible

C. Both nodes are eligible

D. Only the node referenced by a is eligible

Solution

1. Step 1: Analyze references after assignment

   Variable a references a Node with value 1. This node's next points to the Node with value 2.

2. Step 2: Check if nodes are still reachable

   Even though b is set to null, the Node with value 2 is still referenced by a.next. So both nodes are still reachable and not eligible for garbage collection.

3. Final Answer:

   Neither a nor b nodes are eligible -> Option A

4. Quick Check:

   Objects reachable via references are not collected [OK]

Hint: Objects reachable from any reference stay alive [OK]

Common Mistakes:

• Assuming null variable means object is collected
• Ignoring references inside objects
• Confusing variable null with object eligibility