Resource Lifecycle and Cleanup

Starter: think before typing

Before running this resource management example, find the line where the main idea becomes active. Write a prediction: what must already be true for that line to work, and what should be different after it runs? The checked run ends with `Ada`; predict how the focus line helps produce that evidence.

Learning Objectives

• Explain why cleanup matters even in a garbage-collected language.
• Use try-with-resources.
• Distinguish object memory from external resources.
• Design code that makes cleanup hard to forget.

Learning Outcomes

• By the end of the lesson, you can explain why cleanup matters even in a garbage-collected language.
• By the end of the lesson, you can use try-with-resources.
• By the end of the lesson, you can distinguish object memory from external resources.
• By the end of the lesson, you can design code that makes cleanup hard to forget.

Why this idea exists

Resource lifecycle matters because some things a program uses are not ordinary memory: files, streams, sockets, database connections and handles may remain open outside the garbage-collected object model.

Older languages often made cleanup the programmer's direct responsibility, and failures could leak memory or lock resources. Java reduced some of that burden, but constructs such as try-with-resources exist because external resources still need deterministic cleanup.

This lesson fits the arc by widening responsibility from values and objects to the environment around the program. A reliable program must finish its work cleanly, not just produce the right line of output.

Deep dive

Lesson visual

Type this and run it

Create ResourceLifecycleCleanupDemo.java, type the program, and run it before changing anything. This section is about reproducing the checked baseline.

public class ResourceLifecycleCleanupDemo {
  public static void main(String[] args) {
    try (DemoResource resource = new DemoResource("Ada")) {
      System.out.println(resource.read());
    }
  }

  static class DemoResource implements AutoCloseable {
    private final String value;

    DemoResource(String value) {
      this.value = value;
    }

    String read() {
      return value;
    }

    public void close() {
      // Real resources would release a file, stream or socket here.
    }
  }
}

Build and run it with:

javac ResourceLifecycleCleanupDemo.java && java ResourceLifecycleCleanupDemo

Expected baseline: Ada

Line-by-line explanation

Read the code as a sequence of responsibilities. The focus line for this lesson is try (DemoResource resource = new DemoResource("Ada")) {; the surrounding lines prepare it, use its result or make the behaviour observable.

Worked example

Trace the program

Common misconception

A common mistake in resource lifecycle and cleanup is treating the example as a finished answer. For resource management, the important question is narrower: which operation carries the idea, what does it make possible, and what would break if you changed it carelessly?

Quick checks

How to study this lesson

For Resource Lifecycle and Cleanup, predict how resource management changes the run before you press Run.

Use the first portfolio task as your main edit: Use try-with-resources in a tiny example.

Use the second task as your variation: Explain what gets cleaned up.

Finish with evidence, not a diary entry: Compare Java cleanup with the idea of destructors in C++.

Portfolio Practice

1. Use try-with-resources in a tiny example.
2. Explain what gets cleaned up.
3. Compare Java cleanup with the idea of destructors in C++.

Final self-check

Study route

Practise resource management by predicting the Java example, typing it, running it in the browser, tracing the result and saving portfolio evidence.

Next, move into Design Patterns in Practice and carry forward one improvement from this lesson into the next program.