Object lifetime in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Java code involving object references?

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

Java

class Box {
    int value;
    Box(int v) { value = v; }
}

public class Main {
    public static void main(String[] args) {
        Box b1 = new Box(10);
        Box b2 = b1;
        b2.value = 20;
        System.out.println(b1.value);
    }
}

A 10

B Compilation error

C 20

D 0

💡 Hint

Remember that both variables point to the same object in memory.

Both b1 and b2 refer to the same Box object. Changing b2.value changes the same object that b1 points to, so printing b1.value outputs 20.

❓ Predict Output

intermediate

What happens to the object after null assignment?

What will be the output of this Java program?

Java

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

A hello

B Runtime NullPointerException

C Compilation error

D null

💡 Hint

What does printing a null reference print?

Assigning null to s means it no longer points to the string object. Printing s prints the string "null".

❓ Predict Output

advanced

What is the output when an object is eligible for garbage collection?

Consider this Java code. What will be printed?

Java

class Demo {
    protected void finalize() {
        System.out.println("Finalize called");
    }
}

public class Main {
    public static void main(String[] args) {
        Demo d = new Demo();
        d = null;
        System.gc();
        System.out.println("End of main");
    }
}

A End of main

B Compilation error

C Finalize called\nEnd of main

D Runtime error

💡 Hint

Garbage collection and finalize timing is unpredictable.

The finalize() method may not run immediately or at all before the program ends. So only "End of main" is guaranteed to print.

🔧 Debug

advanced

Identify the error related to object lifetime and references

What error will this Java code produce when compiled or run?

Java

public class Main {
    public static void main(String[] args) {
        String s;
        System.out.println(s);
    }
}

A Runtime NullPointerException

B Compilation error: variable s might not have been initialized

C Prints null

D Compilation error: cannot find symbol s

💡 Hint

Local variables must be initialized before use.

The local variable s is declared but not initialized. Java requires local variables to be assigned before use, so this causes a compilation error.

🧠 Conceptual

expert

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

Given the following code, how many objects are eligible for garbage collection immediately after line 10?

1: class Node {
2:   Node next;
3:   Node() { next = null; }
4: }
5: 
6: Node a = new Node();
7: Node b = new Node();
8: a.next = b;
9: b = null;
10: a = null;

A 2

B 1

C 0

D 3

💡 Hint

Think about which objects have no references after line 10.

After line 10, both a and b are null. The two Node objects created have no references and are eligible for garbage collection.

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