3.5 Writing Methods

TLDR

Writing methods in AP Computer Science A means defining the behaviors of a class. A void method runs code but returns nothing, while a non-void method evaluates a return expression and hands back a single value of its return type. When you pass a primitive value into a method, the parameter gets a copy, so changing the parameter never affects the original argument.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

Why This Matters for the AP Computer Science A Exam

Writing methods shows up in both the multiple-choice and free-response sections. You will be asked to determine what a method returns, explain why code does not compile or behave as intended, and write methods that match a given specification. In free-response class design, you build methods inside a class, including accessor and mutator methods that work with private instance variables, so being comfortable writing clear method headers and return logic directly supports that work.

The big skills here are tracing what a method call produces, choosing between void and non-void correctly, and predicting how parameter values behave once a method runs.

Key Takeaways

• A void method does not return a value; a non-void method returns exactly one value that matches its return type.
• The return keyword sends control back to the caller, and any code after a reached return never runs.
• Accessor methods are non-void and hand back a copy of an instance or class variable; mutator methods change variable values and are often void.
• When you pass a primitive argument, the parameter is a copy, so changes inside the method do not affect the original.
• A return inside a loop or if statement stops that statement and exits the whole method right away.

Void vs Non-Void Methods

Every method is either void or non-void, and the header tells you which.

A void method does not return a value. The keyword void appears before the method name in the header.

</>Java
public void setScore(int newScore) {
    score = newScore;
}

A non-void method returns a single value. Instead of void, the header lists the return type, and the method must evaluate a return expression that is compatible with that type.

</>Java
public int getScore() {
    return score;
}

In non-void methods, the return expression is evaluated and its value is handed back to the caller. This is called return by value: the caller receives the value, not the expression itself.

How the return Keyword Controls Flow

The return keyword sends the flow of control back to the point where the method was called. Two rules matter most:

• Any code that comes sequentially after a return will never run.
• A return placed inside a selection (if) or iteration (loop) statement halts that statement and exits the method immediately.

</>Java
public boolean contains(int[] nums, int target) {
    for (int n : nums) {
        if (n == target) {
            return true;   // exits the method right here
        }
    }
    return false;          // only reached if target never found
}

Once return true; runs, the loop stops and the method ends. The final return false; only executes if the loop finishes without finding the target.

Accessor and Mutator Methods

Methods are how you define the behaviors of an object, and two common kinds work directly with a class's variables.

An accessor method (often called a getter) lets objects of other classes obtain a copy of the value of an instance variable or class variable. An accessor is always a non-void method because it returns that value.

</>Java
public String getName() {
    return name;
}

A mutator method (also called a modifier or setter) changes the values of instance variables or class variables. A mutator is often a void method because it updates state rather than returning a value.

</>Java
public void setName(String newName) {
    name = newName;
}

Accessor and mutator methods are how you let outside code interact with private data safely, which keeps the class in control of its own state.

Parameters and Passing Primitives

Methods with parameters receive values through those parameters and use them to do their work. Parameters let you generalize a method so it works with many different inputs.

The key rule for this topic is how primitives are passed. When an argument is a primitive value (like an int, double, boolean, or char), the parameter is initialized with a copy of that value. Changes to the parameter inside the method have no effect on the original argument.

</>Java
public class Demo {
    public static void addTen(int x) {
        x = x + 10;   // changes only the local copy
    }

    public static void main(String[] args) {
        int num = 5;
        addTen(num);
        System.out.println(num);  // prints 5, not 15
    }
}

Even though addTen changes x to 15, the original num stays 5. The parameter x was a separate copy the whole time. This copy behavior is sometimes called pass-by-value for primitives.

Remember the difference between an argument and a parameter: the argument is the actual value you pass in the call (num), and the parameter is the variable in the method header that receives a copy (x).

How to Use This on the AP Computer Science A Exam

Code Tracing

When a question asks what a method returns or prints:

• Check the header first. If it says void, the method returns nothing, so it cannot be used as a value.
• For non-void methods, find the return expression that actually gets reached and evaluate it.
• Stop tracing as soon as a return runs. Code after a reached return does not execute.
• For primitive parameters, remember the method works on a copy. The original variable in the caller does not change.

Free Response

When you write methods for a class design question:

• Match the return type in the header to what the specification says the method should produce. Use void only when nothing is returned.
• Write accessor methods as non-void methods that return the requested variable.
• Write mutator methods that update the instance variable, usually as void methods.
• Make sure every path through a non-void method reaches a return of the correct type.

Common Trap

A common error is writing a non-void method that does not return a value on every possible path, or putting code after a return and expecting it to run. Trace each branch to confirm a value comes back.

Common Misconceptions

• A void method does not "return null." It returns nothing at all, so you cannot use its call as a value in an expression.
• Calling a mutator does not require capturing a return value. Many mutators are void and simply change the object's state.
• Changing a primitive parameter inside a method does not change the caller's variable. The parameter is a copy.
• A return statement does not just set a value and keep going. It immediately exits the method, skipping any remaining code.
• A non-void method must return a value on every path that completes, not only in some branches. A return type in the header is a promise the method must keep.
• return is not the same as printing. Returning a value hands it back to the caller; printing only displays text and does not produce a usable value.

Related AP Computer Science A Guides

• 3.8 Scope and Access
• 3.3 Anatomy of a Class
• 3.9 This Keyword
• 3.7 Static Variables and Methods
• 3.4 Constructors
• 3.1 Abstraction and Program Design