Reference types and how they differ

The shared shopping list

What is a reference type?

Words you'll meet in this lesson

Primitive vs reference at a glance

Kinds of reference types

Ways to get a reference

From new to garbage: the life of an object

1. Declare a reference variable

   StringBuilder list;

   A slot is created on the stack that can hold a reference. No object exists yet.

2. Create an object with new

   list = new StringBuilder("chai");

   new asks the JVM for memory on the heap, builds the object (running its constructor) and returns its reference, which is stored in list.

3. Use it through the reference

   list.append(", samosa");

   The dot means “follow the arrow, then call the method on that object”. The object on the heap changes; the reference in list stays the same.

4. Share it

   StringBuilder kabirList = list;

   Only the reference is copied. Now two arrows point to one object. A change through either variable is visible through both.

5. Let it go

   list = null;
   kabirList = null;

   Once no reference points to the object, it's unreachable. The garbage collector frees its memory later. You never delete objects yourself.

Values vs arrows: both views

Left: the code and what prints. Right: the stack and the heap.

References in real applications

Almost every value in a business application is an object. Understanding references prevents some of the most common production bugs.

Watch it with an example: a customer with no address

A delivery app stores each customer as an object. One customer skipped the address field. Follow the references and see where the famous NullPointerException comes from.

Examples are simplified to show where references matter. Real designs vary.

Shared objects, == and equals

public class Main {
    public static void main(String[] args) {
        StringBuilder list = new StringBuilder("chai");
        StringBuilder kabirList = list;          // same object
        kabirList.append(", samosa");
        System.out.println("Riya's list: " + list);

        String s1 = new String("hi");
        String s2 = new String("hi");
        System.out.println(s1 == s2);            // same object?
        System.out.println(s1.equals(s2));       // same text?

        String coupon = null;
        System.out.println("Coupon present: " + (coupon != null));
    }
}

• new StringBuilder("chai")Creates an object on the heap. list holds its reference.
• StringBuilder kabirList = list;Copies the reference: no new object.
• kabirList.append(…)Changes the shared object, so list sees the change.
• s1 == s2Are they the same object? No: two new calls, two objects.
• s1.equals(s2)Is the text the same? Yes.
• coupon != nullChecking for null before using a reference is a common safety habit.

Follow the arrows

Watch the stack hold arrows while objects appear on the heap. Notice which lines create objects and which only copy arrows.

Worked examples: real problems, solved and traced in memory

A reference variable doesn't hold the object; it holds the way to reach it. These three programs show the consequences: two variables can share one object, Strings never change in place, and an empty reference is null. Watch the arrows from the stack to the heap.

cart "Shoes"; checkout adds ", Gift wrap"

cart:     Shoes, Gift wrap
checkout: Shoes, Gift wrap
same object? true

"Hi", name "Asha"

HI, ASHA
original still: Hi

4 rooms; Asha in room 1 (index 0), Ravi in room 3 (index 2)

Room 1: Asha
Room 2: null
Room 3: Ravi
Room 2 empty? true

Check yourself

Quick revision

Interview and viva questions

Practice problems

Work with references: Strings, arrays and objects, null, and the difference between == and equals. Every output is fixed. The last three are business tasks.

Bengaluru

9 B BENGALURU

public class Main {
    public static void main(String[] args) {
        String city = "Bengaluru";
        System.out.println(city.length() + " " + city.charAt(0) + " " + city.toUpperCase());
    }
}

(none)

null

public class Main {
    public static void main(String[] args) {
        String[] names = new String[2];
        System.out.println(names[0]);
    }
}

{5, 10, 15, 20}

4 20

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 10, 15, 20};
        System.out.println(a.length + " " + a[a.length - 1]);
    }
}

(none)

false true

public class Main {
    public static void main(String[] args) {
        String a = "pune";
        String b = new String("pune");
        System.out.println((a == b) + " " + a.equals(b));
    }
}

a = {1, 2, 3}

99

public class Main {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = a;
        b[0] = 99;
        System.out.println(a[0]);
    }
}

null, then "Meena"

Name given? false
Name given? true, name: Meena

public class Main {
    public static void main(String[] args) {
        String name = null;
        System.out.println("Name given? " + (name != null));
        name = "Meena";
        System.out.println("Name given? " + (name != null) + ", name: " + name);
    }
}

save50

Valid: true

public class Main {
    public static void main(String[] args) {
        String typed = "save50";
        System.out.println("Valid: " + typed.equalsIgnoreCase("SAVE50"));
    }
}

ORD-11, ORD-12, ORD-13

1. ORD-11
2. ORD-12
3. ORD-13

public class Main {
    public static void main(String[] args) {
        String[] orders = {"ORD-11", "ORD-12", "ORD-13"};
        System.out.println("1. " + orders[0]);
        System.out.println("2. " + orders[1]);
        System.out.println("3. " + orders[2]);
    }
}

Real-world scenario questions (asked in company interviews)

Reference bugs are subtle: the code compiles and often works in testing. Decide your answer first, then open the model answer.