Methods: How to Write Them - AP Computer Science A

SECTION 1

Historical Context & Motivation

The concept of a method — a named, reusable block of code that performs a specific task — is one of the oldest and most powerful ideas in software engineering. Before methods (and their close relatives, subroutines and procedures), early programmers wrote monolithic sequences of instructions where the same logic was duplicated every time it was needed. This made programs fragile, enormous, and nearly impossible to debug. The quest for a better abstraction ultimately led to the structured programming revolution and, later, to the object-oriented paradigm that Java embodies.

1950s • Subroutines in Assembly

Early assembly languages introduced the CALL/RETURN pattern, allowing programmers to jump to a block of code and return to the caller — the conceptual ancestor of every method you write today.

1960 • ALGOL 60 & Formal Parameters

ALGOL 60 formalized the notion of block structure and parameter passing, giving methods their own local scope. This separation of concerns became foundational to all later languages.

1972 • C Language & Functions

Dennis Ritchie's C language made functions first-class organizational units with explicit return types and parameter lists, establishing the syntax style that Java would later adopt.

1995 • Java & Object-Oriented Methods

Java launched with methods tightly coupled to classes. Every method must belong to a class, reinforcing the object-oriented principle that data and behavior are inseparable.

The central question this lesson addresses is deceptively simple: How do you declare, define, and invoke a method in Java so that your classes are modular, readable, and correct? Understanding the precise syntax and semantics of method writing is essential for the AP Computer Science A exam, where free-response questions routinely require you to author complete methods from scratch.

SECTION 2

Core Principles of Method Design

A well-designed method embodies several foundational principles that you will encounter repeatedly on the AP exam and in professional software development. These principles govern not only how you write a method signature, but also how you reason about what the method should do, what it should receive, and what it should return.

Single Responsibility

Each method should do one thing and do it well. A method named calculateAverage should compute and return an average — not also print it, sort the array, or modify a global variable.

Encapsulation via Access

The access modifier (public or private) controls who may call the method. Keeping helper methods private limits external dependencies and protects internal logic.

Clear Contract (Signature)

A method's signature — its name, parameter list, and return type — serves as a contract. The caller knows exactly what inputs to supply and what output to expect, without needing to read the method body.

Pass-by-Value Semantics

Java passes all arguments by value. For primitives, the method receives a copy. For objects, the method receives a copy of the reference, meaning it can modify the object's state but cannot reassign the caller's variable.

Return vs. Void

A method either returns a value of the declared type or is declared void if it performs an action without producing a result. Every non-void path through the method body must end with a return statement.

SECTION 3

Anatomy of a Method — Visual Breakdown

The diagram below dissects a complete Java method into its constituent parts. Each colored region corresponds to a syntactic element that the compiler checks. Understanding this anatomy is critical: on the AP exam, you will be asked both to read existing methods and to write new ones from a prose specification.

Each color-coded label identifies a syntactic component: the access modifier (purple), the optional static keyword (pink), the return type (cyan), the method name (green), the parameter list (amber), and the return statement (red) inside the method body.

Notice that the method header (the first line before the opening brace) is a complete declaration of the method's interface. The compiler uses this header to verify that every call site provides the correct argument types and that the caller handles the return type appropriately. On the AP exam, the static keyword appears primarily in the context of public static void main(String[] args); most methods you write for free-response questions will be instance methods (non-static), meaning they operate on the specific object that invoked them.

SECTION 4

How Methods Work: Execution Flow & Memory

When a method is called, the Java Virtual Machine allocates a new stack frame on the call stack. This frame stores the method's local variables, the values of its parameters, and the return address — the point in the calling method where execution should resume once the method finishes. Understanding this mechanism clarifies several behaviors that the AP exam tests: why local variables vanish after a method returns, why primitive parameters cannot be changed by the callee, and why reassigning an object reference inside a method does not affect the caller.

Method Signature Syntax

GENERAL METHOD HEADER

accessModifier returnType methodName(paramType₁ param₁, paramType₂ param₂, ...)

accessModifier — public or private (AP subset). returnType — any data type, or void for no return. methodName — a camelCase identifier describing the action. parameters — zero or more typed inputs separated by commas.

Void vs. Non-Void Methods

VOID METHOD PATTERN

public void printGreeting(String name) { System.out.println("Hello, " + name); }

A void method performs an action (a side effect) but does not return a value. It may optionally contain return; (with no expression) to exit early.

NON-VOID METHOD PATTERN

public int square(int x) { return x * x; }

A non-void method must return a value whose type matches (or is compatible with) the declared return type. Every possible execution path must reach a return statement, or the code will not compile.

Pass-by-Value in Detail

Java's pass-by-value rule is straightforward for primitives: the called method receives a copy of the value, so any modifications are invisible to the caller. For reference types (objects and arrays), Java copies the reference itself. This means the method can call mutator methods on the same object the caller sees, but if the method reassigns the parameter variable to point to a new object, the caller's reference is unaffected. This distinction is a perennial source of exam questions, so practice tracing through examples carefully.

ℹ

AP Exam Tip

SECTION 5

Types of Methods You Must Know

On the AP exam, methods fall into several recognizable categories. Understanding these categories helps you approach FRQs efficiently, because each type follows predictable structural patterns. The diagram below classifies the method types you need to master, while the table that follows provides a quick reference with concrete examples.

The hierarchy shows that instance methods branch into accessors (which return data without changing state), mutators (which modify state), and constructors (which initialize new objects). Static methods stand apart because they operate without an implicit this reference.

Method Type	Return Type	Modifies State?	Example Signature
Accessor (getter)	Non-void (e.g., `int`, `String`)	No	`public String getName()`
Mutator (setter)	Usually `void`	Yes	`public void setName(String n)`
Constructor	None (no return type declared)	Yes (initializes)	`public Student(String name, int grade)`
Static utility	Any type	No instance state	`public static int max(int a, int b)`
toString	`String`	No	`public String toString()`

Common method types in the AP Computer Science A subset

SECTION 6

Worked Example: Writing a Complete Class with Methods

Suppose you are asked to design a BankAccount class with instance variables for the owner's name and the balance, a constructor, accessor methods for both fields, a deposit method, a withdraw method that rejects overdrafts, and a toString method. This mirrors a typical AP FRQ prompt in both scope and level of detail.

Worked example

1
Step 1 — Declare Instance Variables

Based on the prompt, we need two instance variables. We declare them private to enforce encapsulation: private String owner; private double balance;

Two private fields declared.
2
Step 2 — Write the Constructor

A constructor has the same name as the class and no return type. It initializes instance variables from parameters: public BankAccount(String owner, double initialBalance) { this.owner = owner; this.balance = initialBalance; } Using this disambiguates between the parameter and the field when they share a name.

Constructor initializes both fields.
3
Step 3 — Write Accessor Methods

Accessors (getters) return the value of a private field without changing it: public String getOwner() { return owner; } public double getBalance() { return balance; } Note the return types match the field types exactly.

Two getter methods, both non-void.
4
Step 4 — Write the deposit Mutator

The deposit method takes an amount and adds it to the balance. It is void because it modifies state rather than producing a return value: public void deposit(double amount) { balance += amount; }

Void mutator that increases balance.
5
Step 5 — Write the withdraw Mutator with Guard Clause

The withdraw method must reject overdrafts. We use an if statement as a guard clause and return a boolean to indicate success or failure: public boolean withdraw(double amount) { if (amount > balance) { return false; } balance -= amount; return true; } Every execution path ends with a return — this is essential for compilation.

Non-void mutator returning boolean to signal success.
6
Step 6 — Write toString

The toString method returns a String representation of the object. It is called automatically by System.out.println: public String toString() { return owner + ": $" + balance; }

Accessor returning a formatted String.

SECTION 7

Common Pitfalls & How to Avoid Them

Even confident programmers lose points on the AP exam due to subtle method-writing mistakes. The table below catalogs the most frequent errors graders see, along with the fix and the underlying principle. Internalizing these will help you self-check during the exam.

Pitfall	What Goes Wrong	How to Fix It
Missing return statement	A non-void method has a path (e.g., an `if` branch) that does not reach a `return`. Code will not compile.	Ensure every possible path through the method ends with a `return`. Add a default `return` after conditional blocks.
Printing instead of returning	The method uses `System.out.println` to display a result but never returns it. The caller receives nothing.	Use `return` to send the result back. Print only when the prompt explicitly asks for console output.
Wrong return type	Returning an `int` when the header declares `double` (or vice versa in a lossy direction). May cause truncation.	Double-check that the return expression's type matches or is promotable to the declared return type.
Modifying a primitive parameter	Changing a parameter of type `int` inside the method, expecting the caller's variable to change. It won't — pass-by-value.	Return the new value instead, or redesign the method to use an instance variable.
Using the wrong scope	Declaring a local variable with the same name as an instance variable, unintentionally shadowing it.	Use `this.fieldName` to access the instance variable explicitly, or choose a different local name.

Top 5 method-writing pitfalls on the AP exam

★

Key takeaway

DEBUGGING MINDSET

SECTION 8

Connecting Methods to Advanced OOP Concepts

The methods you write in individual classes are the building blocks for more advanced object-oriented features that appear later in the AP curriculum. Understanding how basic method authoring scales into polymorphism, overriding, and interface implementation will give you a conceptual preview that deepens your understanding of why precise method signatures matter.

Basic Concept (This Lesson)	Advanced Extension (Later Units)
Writing a method with a specific signature	Method overriding — a subclass provides its own version of an inherited method, keeping the exact same signature.
Using `public` vs. `private`	Encapsulation in inheritance — subclasses cannot access `private` methods directly; they rely on the `public` interface of the superclass.
Defining parameters and return types	Polymorphic method calls — a variable declared as a superclass type can invoke overridden methods on a subclass object at runtime.
Constructor writing	Constructor chaining — using `super()` to invoke a superclass constructor, leveraging existing initialization logic.
`toString()` method	Overriding Object methods — `toString()` and `equals()` are inherited from `Object` and customized in every well-designed class.

How basic method writing connects to later AP units

As you progress through the course, you will see that every advanced technique — overriding, abstract methods, interface implementation — rests on the same syntactic foundation you are mastering now. A student who writes crisp, correct method signatures in Unit 5 will find Units 9 and 10 (Inheritance and Recursion) far more manageable, because the mechanics of declaring, implementing, and invoking methods become second nature.

SECTION 9

Practice Problems

Question 1: CONCEPTUAL

Consider the following method header:public int computeSum(int a, int b)Which of the following statements about this method is true?

A. The method can be called without creating an object of the class.
B. The method must contain exactly one return statement.
C. Every possible execution path through the method body must return an int value.
D. The parameters a and b are instance variables of the class.

Show answer (C)

C is correct. Because the return type is int (non-void), the compiler requires that every possible execution path ends with a return statement that produces an int value. A is incorrect because the method is not declared static, so it requires an instance (object) of the class to be called. B is incorrect because a method may contain multiple return statements (e.g., inside different branches of an if-else); the requirement is only that every path returns a value, not that there is exactly one return. D is incorrect because a and b are parameters — they are local to the method and exist only for the duration of the call. They are not instance variables.

Question 2: BASIC

Consider the following class:

public class Counter {
    private int count;
    public Counter() { count = 0; }
    public void increment() { count++; }
    public int getCount() { return count; }
}

What is the output of the following code segment?

Counter c = new Counter();
c.increment();
c.increment();
c.increment();
System.out.println(c.getCount());

A. 0
B. 1
C. 3
D. The code does not compile because increment has no return value.

Show answer (C)

C is correct. The constructor initializes count to 0. Each call to increment() adds 1, so after three calls, count is 3. The getCount() accessor returns 3, which is printed. A is incorrect because it ignores the three increment calls. B is incorrect because it only accounts for one increment. D is incorrect because a void method compiles perfectly — it simply cannot be used in an expression that expects a value.

Question 3: INTERMEDIATE

Consider the following method:

public String categorize(int score) {
    if (score >= 90) {
        return "A";
    } else if (score >= 80) {
        return "B";
    } else if (score >= 70) {
        return "C";
    }
}

Which of the following best describes the problem with this method?

A. The method will compile but return null for scores below 70.
B. The method will not compile because not all execution paths return a value.
C. The method will throw a NullPointerException for scores below 70.
D. The method will compile and return an empty String for scores below 70.

Show answer (B)

B is correct. The method declares a return type of String, but if score is below 70, no return statement is reached. The Java compiler detects this missing path and refuses to compile the code. A is incorrect because the code never reaches the compilation stage — it cannot run at all. C is incorrect for the same reason: runtime exceptions can only occur if the code compiles first. D is incorrect because Java does not automatically return a default value for non-void methods when the end of the method body is reached. The fix is to add a final return "F"; after the last else if or use an else block.

Question 4: APPLIED

4 pts

A Thermostat class has the following instance variables:

private double currentTemp;
private double targetTemp;

Write a method adjustTarget that takes a double parameter delta and increases or decreases targetTemp by that amount. The method should enforce that targetTemp never goes below 50.0 or above 90.0. If the adjustment would exceed either bound, set targetTemp to the nearest bound instead. The method returns the new targetTemp.

Show answer

Sample Solution:

public double adjustTarget(double delta) {
    targetTemp += delta;
    if (targetTemp < 50.0) {
        targetTemp = 50.0;
    } else if (targetTemp > 90.0) {
        targetTemp = 90.0;
    }
    return targetTemp;
}

Rubric (4 points): Point 1: Correct method header — public double adjustTarget(double delta) with proper access modifier, return type, method name, and parameter. Point 2: Correctly adjusts targetTemp by adding delta (handles both positive and negative values). Point 3: Correctly clamps targetTemp to the range [50.0, 90.0] using conditional logic that handles both the lower and upper bounds. Point 4: Returns the updated targetTemp value. The return type matches the declared double, and the return occurs on every execution path.

Question 5: CRITICAL THINKING

3 pts

A student writes the following method inside a Roster class that stores an ArrayList<String> called names:

public void replaceAll(ArrayList<String> names, String oldName, String newName) {
    for (int i = 0; i < names.size(); i++) {
        if (names.get(i).equals(oldName)) {
            names.set(i, newName);
        }
    }
}

Identify and explain the design flaw in this method. Describe how you would fix the method and explain why the fix is an improvement in terms of encapsulation.

Show answer

Rubric (3 points): Point 1 — Identify the flaw: The method accepts an ArrayList<String> names parameter that shadows the instance variable names. The method operates on whichever list the caller passes in, rather than on the object's own data. If the caller passes a different list, the object's internal names is never modified. Point 2 — Describe the fix: Remove the ArrayList<String> names parameter entirely. The method should use the instance variable directly (or via this.names): public void replaceAll(String oldName, String newName). Inside the body, references to names will resolve to the instance field. Point 3 — Explain the encapsulation improvement: By removing the parameter, the method no longer exposes the internal ArrayList as part of its public interface. Callers do not need to know the internal data structure — they simply invoke replaceAll("OldName", "NewName") and the object manages its own state. This upholds the principle of encapsulation: instance methods should operate on the object's own fields, not require the caller to supply internal data.