Java Reference Types

Reference types in Java store addresses that point to objects in memory. Unlike primitive types, they don't hold the actual data but references to where the data is stored.

Types of Reference Variables

Objects

Instances of classes that contain both data (fields) and behavior (methods).

// Creating objects
String name = new String("Java Developer");
Date today = new Date();
ArrayList<String> list = new ArrayList<>();

// Object references point to memory locations
String str1 = "Hello";
String str2 = str1;  // Both reference the same object

Arrays

Collections of elements of the same type stored in contiguous memory.

// Array declarations
int[] numbers = new int[5];
String[] names = new String[3];
int[][] matrix = new int[3][3];  // 2D array

// Array initialization
int[] primes = {2, 3, 5, 7, 11};
String[] days = {"Mon", "Tue", "Wed", "Thu", "Fri"};

Strings

Special objects for text manipulation with unique memory handling.

// String literals (stored in string pool)
String literal1 = "Hello";
String literal2 = "Hello";  // Same object as literal1

// String objects (stored in heap)
String object1 = new String("Hello");
String object2 = new String("Hello");  // Different object

Memory Management

Stack vs Heap

Stack Memory

Stores primitive variables and reference variables
Fast access
Limited size
Automatically managed (LIFO order)

public void method() {
    int x = 10;              // Stack
    String name = "Java";    // Reference on stack, object on heap
    int[] numbers = new int[5]; // Reference on stack, array on heap
}

Heap Memory

Stores objects and arrays
Larger size
Slower access than stack
Managed by garbage collector

// These objects are created in heap memory
Person person = new Person("Alice", 25);
List<Integer> list = new ArrayList<>();
int[] largeArray = new int[1000000];

Object Lifecycle

Creation

// 1. Declaration (reference on stack)
Person person;

// 2. Instantiation (object on heap)
person = new Person("Alice", 25);

// 3. Initialization
person.setName("Alice Smith");

Usage

// Accessing object members
String name = person.getName();
person.setAge(26);

// Method calls
person.birthday();  // Increments age

Garbage Collection

public void createObjects() {
    Person person1 = new Person("Alice");
    Person person2 = new Person("Bob");
    
    person1 = null;  // Eligible for garbage collection
    // person2 still referenced
} // person2 becomes eligible at method end

Reference Types in Detail

Class Objects

public class Car {
    private String model;
    private int year;
    
    public Car(String model, int year) {
        this.model = model;
        this.year = year;
    }
    
    // Methods...
}

// Usage
Car myCar = new Car("Toyota", 2023);
Car yourCar = myCar;  // Both reference same object

Interface References

// Interface reference pointing to implementation
List<String> list = new ArrayList<>();
Map<String, Integer> map = new HashMap<>();
Runnable task = new MyTask();

Abstract Class References

// Abstract class reference pointing to concrete implementation
Animal dog = new Dog();
Animal cat = new Cat();

Special Reference Types

Null Reference

String text = null;  // Reference to nothing
if (text != null) {
    System.out.println(text.length());
}

This Reference

public class Person {
    private String name;
    
    public void setName(String name) {
        this.name = name;  // 'this' refers to current object
    }
}

Super Reference

public class Student extends Person {
    public void displayInfo() {
        super.displayInfo();  // Calls parent method
        System.out.println("Student info");
    }
}

Pass by Value vs Pass by Reference

Java is always pass-by-value, but with reference types, the value passed is the reference.

public void modifyString(String str) {
    str = str + " Modified";  // Creates new string, doesn't change original
}

public void modifyList(List<String> list) {
    list.add("New Item");  // Modifies the object referenced
}

String original = "Hello";
modifyString(original);
System.out.println(original);  // Still "Hello"

List<String> items = new ArrayList<>();
items.add("Original");
modifyList(items);
System.out.println(items);  // Contains "Original" and "New Item"

Comparison of Reference Types

Equality (== vs equals)

String str1 = new String("Hello");
String str2 = new String("Hello");
String str3 = str1;

System.out.println(str1 == str2);    // false (different objects)
System.out.println(str1.equals(str2)); // true (same content)
System.out.println(str1 == str3);    // true (same object)

Arrays Comparison

int[] arr1 = {1, 2, 3};
int[] arr2 = {1, 2, 3};
int[] arr3 = arr1;

System.out.println(arr1 == arr2);    // false (different arrays)
System.out.println(Arrays.equals(arr1, arr2)); // true (same contents)
System.out.println(arr1 == arr3);    // true (same array)

Memory Optimization

Object Reuse

// Good: Reuse objects
StringBuilder builder = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    builder.setLength(0);  // Clear and reuse
    builder.append("Item ").append(i);
    process(builder.toString());
}

// Bad: Creating many objects
for (int i = 0; i < 1000; i++) {
    String str = "Item " + i;  // Creates new string each iteration
    process(str);
}

Weak References

import java.lang.ref.WeakReference;

WeakReference<Person> weakRef = new WeakReference<>(new Person("Temp"));
Person person = weakRef.get();  // May return null if garbage collected

Best Practices

Initialize references to avoid NullPointerException
Use null checks before accessing object members
Prefer interfaces for reference types when possible
Be aware of object creation in loops
Use appropriate collection types based on usage patterns
Consider memory usage when creating large objects

Common Pitfalls

NullPointerException: Accessing null reference
Memory leaks: Holding references to unused objects
Unnecessary object creation: In loops or frequent methods
String concatenation: Using + in loops creates many objects
Array vs ArrayList: Fixed vs dynamic size considerations

Understanding reference types and memory management is crucial for writing efficient and robust Java applications.