Heap memory in Java - Mini Project: Build & Apply

Understanding Heap Memory in Java

📖 Scenario: Imagine you are managing a small library system where you keep track of books. Each book has a title and an author. You want to understand how Java stores objects like books in heap memory.

🎯 Goal: You will create a simple Java program that creates book objects stored in heap memory, then display their details. This will help you see how objects live in heap memory and how references work.

📋 What You'll Learn

Create a Book class with title and author fields

Create two Book objects with exact titles and authors

Store the Book objects in variables

Print the details of each Book object

💡 Why This Matters

🌍 Real World

Understanding heap memory helps you manage objects in Java programs, like managing books in a library system or users in an app.

💼 Career

Knowing how objects are stored and accessed in heap memory is essential for Java developers to write efficient and bug-free code.

1

Create the Book class

Create a public class called Book with two public String fields: title and author. Do not add any methods yet.

Java

// Your code here

Hint

Use public class Book {} and inside it declare public String title; and public String author;.

2

Create two Book objects

In the main method of a Library class, create two Book objects named book1 and book2. Set book1.title to "Java Basics" and book1.author to "Alice". Set book2.title to "Data Structures" and book2.author to "Bob". Use the new keyword to create the objects.

Java

public class Book {
    public String title;
    public String author;
}

public class Library {
    public static void main(String[] args) {
        // Create book1 and book2 objects with titles and authors
        // Your code here
    }
}

Hint

Use Book book1 = new Book(); then set fields with book1.title = "Java Basics"; and book1.author = "Alice";. Repeat for book2.

3

Add a method to print book details

Add a public method called printDetails inside the Book class. This method should print the book's title and author in the format: Title: [title], Author: [author].

Java

public class Book {
    public String title;
    public String author;
    // Add printDetails method here
    // Your code here
}

public class Library {
    public static void main(String[] args) {
        Book book1 = new Book();
        book1.title = "Java Basics";
        book1.author = "Alice";

        Book book2 = new Book();
        book2.title = "Data Structures";
        book2.author = "Bob";
    }
}

Hint

Define public void printDetails() and inside use System.out.println to show title and author.

4

Print details of both books

In the main method of Library, call the printDetails method on both book1 and book2 to display their information.

Java

public class Book {
    public String title;
    public String author;

    public void printDetails() {
        System.out.println("Title: " + title + ", Author: " + author);
    }
}

public class Library {
    public static void main(String[] args) {
        Book book1 = new Book();
        book1.title = "Java Basics";
        book1.author = "Alice";

        Book book2 = new Book();
        book2.title = "Data Structures";
        book2.author = "Bob";

        // Call printDetails on book1 and book2
        // Your code here
    }
}

Hint

Use book1.printDetails(); and book2.printDetails(); to show the book details.

Practice

1. Which of the following best describes heap memory in Java?

easy

A. It stores method call information and local variables.

B. It stores primitive variables like int and double.

C. It stores all objects created using new keyword.

D. It stores the Java bytecode instructions.

Solution

1. Step 1: Understand what heap memory stores

   Heap memory is used to store objects created dynamically using the new keyword in Java.

2. Step 2: Differentiate from other memory areas

   Primitive variables and method calls are stored on the stack, not heap. Bytecode is stored in method area, not heap.

3. Final Answer:

   It stores all objects created using new keyword. -> Option C

4. Quick Check:

   Heap memory = objects from new [OK]

Hint: Heap = objects created with new keyword [OK]

Common Mistakes:

• Confusing stack with heap memory
• Thinking primitives are stored in heap
• Mixing method area with heap

2. Which of the following Java statements correctly creates an object stored in heap memory?

easy

A. String s = new String("hello");

B. int x = 5;

C. double y = 3.14;

D. boolean flag = true;

Solution

1. Step 1: Identify object creation syntax

   Objects in Java are created using the new keyword, which allocates memory on the heap.

2. Step 2: Check each option

   String s = new String("hello"); uses new String("hello"), which creates a String object on the heap. Other options declare primitives stored on the stack.

3. Final Answer:

   String s = new String("hello"); -> Option A

4. Quick Check:

   Object creation uses new keyword [OK]

Hint: Look for 'new' keyword to spot heap allocation [OK]

Common Mistakes:

• Assuming primitives use heap
• Confusing string literals with new String()
• Ignoring that only new creates heap objects

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

class Test {
  public static void main(String[] args) {
    String a = new String("abc");
    String b = a;
    a = null;
    System.out.println(b);
  }
}

medium

A. null

B. Runtime exception

C. Compilation error

D. abc

Solution

1. Step 1: Understand object references and heap

   Variable a points to a String object "abc" in heap. Then b is assigned the same reference.

2. Step 2: Analyze effect of setting a to null

   Setting a = null removes one reference, but b still points to the object, so it remains accessible.

3. Step 3: Print b

   Printing b outputs the string "abc".

4. Final Answer:

   abc -> Option D

5. Quick Check:

   Reference b still points to "abc" [OK]

Hint: Nulling one reference doesn't delete object if others exist [OK]

Common Mistakes:

• Assuming object is deleted when one reference is null
• Confusing references with objects
• Expecting null output incorrectly

4. Identify the error in the following Java code related to heap memory usage:

public class Demo {
  public static void main(String[] args) {
    int[] arr = new int[5];
    arr = null;
    System.out.println(arr.length);
  }
}

medium

A. No error, prints 5

B. NullPointerException at runtime

C. Compilation error due to null assignment

D. Array size becomes zero

Solution

1. Step 1: Understand array creation and null assignment

   The array is created on heap with size 5, then arr reference is set to null.

2. Step 2: Analyze printing arr.length

   Since arr is null, accessing arr.length causes a NullPointerException at runtime.

3. Final Answer:

   NullPointerException at runtime -> Option B

4. Quick Check:

   Accessing member on null reference throws exception [OK]

Hint: Accessing null reference causes NullPointerException [OK]

Common Mistakes:

• Thinking null assignment causes compile error
• Expecting array length to print after null
• Confusing null with empty array

5. Consider this Java code snippet:

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

public class Test {
  public static void main(String[] args) {
    Node n1 = new Node(1);
    Node n2 = new Node(2);
    n1.next = n2;
    n2.next = n1;
    n1 = null;
    n2 = null;
    // What happens to the Node objects in heap?
  }
}

What happens to the two Node objects in heap after n1 and n2 are set to null?

hard

A. Both objects become unreachable and eligible for garbage collection.

B. Objects remain in heap because they reference each other, preventing garbage collection.

C. Only n1 object is collected, n2 remains.

D. Objects cause a memory leak and crash the program.

Solution

1. Step 1: Analyze object references after null assignments

   Both n1 and n2 references are set to null, so no external references point to these objects.

2. Step 2: Understand garbage collection with cyclic references

   Even though the two objects reference each other, Java's garbage collector detects unreachable cycles and frees them.

3. Final Answer:

   Both objects become unreachable and eligible for garbage collection. -> Option A

4. Quick Check:

   Unreachable objects, even cyclic, are collected [OK]

Hint: Java GC collects unreachable cyclic objects too [OK]

Common Mistakes:

• Thinking cyclic references prevent garbage collection
• Assuming memory leak without external references
• Confusing references with reachability