Methods: Passing and Returning References of an Object - AP Computer Science A Study Guide

Getting Started

In programming, we often need methods to work with complex data structures, not just simple numbers or text. To solve this, Java allows methods to accept entire objects as input and to produce objects as output. Understanding how Java handles objects when they are passed to and returned from methods is fundamental to building powerful, modular, and object-oriented programs.

What You Should Be Able to Do

• Write a method that accepts a reference to an object as a parameter.

• Write a method that returns a reference to an object.

• Trace the execution of a program that passes an object to a method.

• Explain how a method can change the state of an object passed as a parameter.

• Differentiate between passing a primitive type and passing an object reference to a method.

Key Concepts & Java Implementation

The Core Idea

Java methods operate on a principle called pass-by-value. This means when you pass a variable to a method, a copy of that variable's value is created and given to the method's parameter.

This has two important implications:

1. For Primitive Types (int, double, boolean): The method gets a copy of the actual value. Any changes the method makes to its parameter do not affect the original variable outside the method.

2. For Object Types (String, Scanner, custom classes): The "value" of an object variable is not the object itself, but a reference—the object's address in memory. When you pass an object to a method, the method gets a copy of the reference. Both the original variable and the method's parameter now point to the exact same object in memory.

Because both references point to the same object, if the method uses its reference to change the object's internal state (i.e., modify its instance variables), the change will be visible outside the method. Think of it like giving a friend a copy of your house address. They can't change your original piece of paper with the address on it, but they can use their copy to go to your house and paint the front door.

Syntax & Implementation

To illustrate these concepts, let's use a simple Car class.

// A simple class to represent a Car

public class Car {

    private String model;

    private int year;


    // Constructor to initialize the Car object

    public Car(String model, int year) {

        this.model = model;

        this.year = year;

    }


    // A "getter" method to access the year

    public int getYear() {

        return this.year;

    }


    // A "setter" method to modify the year

    public void setYear(int year) {

        this.year = year;

    }

    

    // A method to represent the object as a String

    public String toString() {

        return this.year + " " + this.model;

    }

}

Passing Objects as Parameters

A method can accept an object as a parameter by specifying the class name as the parameter's type. This method can then call the object's methods to modify its state.

Annotated Java Example: Modifying an Object

public class CarManager {


    // This method accepts a Car object reference.

    // The parameter 'vehicle' will point to the same object as the argument passed in.

    public static void repaintAndAge(Car vehicle, int newYear) {

        System.out.println("-> Inside method: Modifying the Car object.");

        vehicle.setYear(newYear); // This changes the state of the original object.

    }


    public static void main(String[] args) {

        // 1. Create a Car object. myCar holds a reference to it.

        Car myCar = new Car("Sedan", 2020);

        System.out.println("Before method call: " + myCar.toString());


        // 2. Pass the reference to the method.

        //    A copy of the reference in 'myCar' is passed to 'repaintAndAge'.

        repaintAndAge(myCar, 2024);


        // 3. The change is visible here because 'myCar' still points to the

        //    same object that the method modified.

        System.out.println("After method call: " + myCar.toString());

    }

}

Output:

Before method call: 2020 Sedan

-> Inside method: Modifying the Car object.

After method call: 2024 Sedan

Returning Objects from Methods

A method can also create a new object and return a reference to it. The method's return type must be the name of the class.

Annotated Java Example: Creating and Returning an Object

public class CarFactory {


    // This method's return type is 'Car'. It will return a reference

    // to a new Car object.

    public static Car buildCustomCar(String model, int year) {

        // 1. A new Car object is created inside the method.

        Car newCar = new Car(model, year);

        

        // 2. The reference to the new object is returned.

        return newCar;

    }


    public static void main(String[] args) {

        System.out.println("Calling factory method to build a car...");

        

        // The returned reference is stored in the 'sportsCar' variable.

        Car sportsCar = buildCustomCar("Coupe", 2025);

        

        System.out.println("Car created: " + sportsCar.toString());

    }

}

Output:

Calling factory method to build a car...

Car created: 2025 Coupe

Tracing & Analysis

Let's trace the execution of the CarManager example to see how the reference passing works.

Execution Trace

Analysis

The key takeaway is that the repaintAndAge method did not—and cannot—change the myCar variable itself. For example, if the method had a line vehicle = null;, it would only make the vehicle parameter null; the myCar variable in main would still point to the Car object. However, the method can use its copy of the reference (vehicle) to access and modify the object's internal state.

Java Syntax Quick-Reference

A compact summary of syntax used for passing and returning objects.

Core Code Examples & Terminology

• Object: An instance of a class. An object has a state (data stored in instance variables) and behavior (actions defined by its methods).

• Reference: A variable that holds the memory address of an object. It "points to" an object but is not the object itself.

• Parameter: A variable in a method's signature that receives a value or a reference when the method is called.

• Return Type: The data type (e.g., int, String, or a class name) specified in a method signature that indicates what kind of value or reference the method will send back.

• Instance Variable: A variable declared inside a class but outside any method. Each object (instance) of the class gets its own copy of this variable.

• Core Snippet 1: Passing an Object to a Method

  
  // Method that modifies an object's state
  
  public void updatePrice(Product item, double newPrice) {
  
      item.setPrice(newPrice);
  
  }
  

  This method accepts a Product object reference and uses it to call a method that changes the object's internal price.

• Core Snippet 2: Returning an Object from a Method

  
  // Method that creates and returns an object
  
  public Student createHonorStudent(String name) {
  
      Student s = new Student(name, 4.0);
  
      return s;
  
  }
  

  This method constructs a new Student object and returns a reference to it.

Core Skill Check

• Code Tracing: What is printed by the last line of this Java code?

  
  // Assume a Point class with public int x, y;
  
  Point p1 = new Point(10, 20);
  
  Point p2 = p1;
  
  p2.x = 30;
  
  System.out.println(p1.x);
  

  Answer: 30

• Debugging: Identify the compile-time error in this Java code.

  
  public class BoxFactory {
  
      public void makeBox(int w, int h) {
  
          Box b = new Box(w, h);
  
          return b; // Error is here
  
      }
  
  }
  

  Answer: The method has a void return type but tries to return a Box object. The return type should be Box.

• Application: Write a single line of Java code to create a Book object named myBook by calling a static method createFromTitle in the Library class, passing it the string "Moby Dick".

  Answer: Book myBook = Library.createFromTitle("Moby Dick");

Common Misconceptions & Errors

1. "Java is pass-by-reference."

   This is incorrect. Java is strictly pass-by-value. The confusion arises because for objects, the value that gets copied is the reference. A method cannot change the caller's original reference variable to point to a different object.

2. Confusing Object State Change with Reference Reassignment.

   A method can change an object's instance variables (its state). It cannot reassign the original variable that was passed in. If a method parameter is set to null or a new object, it only affects the parameter inside the method, not the variable in the calling code.

3. Expecting a new Object When One Isn't Created.

   If a method modifies the object passed to it but does not use the new keyword, no new object is created. Both the caller and the method are working with the same object.

Summary

Methods are essential for organizing code and working with data. In Java, methods can accept objects as parameters and return objects as results. When an object is passed to a method, a copy of its reference is passed, allowing the method to access and modify the original object's state. This is a powerful feature for building interconnected systems. Similarly, methods can act as "factories," constructing new objects and returning references to them, which allows for clean and encapsulated object creation. Mastering how references are passed and returned is a critical step in becoming a proficient Java programmer.