Methods: How to Write Them

In Topics 3.3 and 3.4 you built classes with private instance variables and a constructor. A StepTracker object can be created holding 4,200 steps, but then it just sits there. Its instance variable is private, so main cannot even look at it. An object that cannot do anything is not very useful. A class needs behaviors: things its objects can do, such as report their steps or record a walk.

You already know how to read methods. In Topic 1.9 you read headers like public static void printTotal(double ticketPrice, int tickets), and in Topic 1.14 you called methods on objects with a dot, as in word.length(). Now you write methods yourself, inside your own class, so that your objects can be called the same way.

In plain words: a method written inside a class is a named set of instructions that every object of that class carries. When you call it on one object, the instructions run using that object’s instance variables.

Here is the simplest kind. A void method is a method that does not return a value. Its header has the keyword void in front of the method’s name, in the spot where a return type would go. Because nothing comes back, a call to a void method is always a statement on its own, like tracker.printSummary();.

Here is a void method inside the StepTracker class, with each piece of its header labeled:

public void printSummary()
{
    System.out.println("Steps so far: " + steps);
}

The body uses steps even though steps is private. That is allowed because the method is inside the class; private only keeps out code from other classes. This is the reason classes have methods at all: the method is the class’s own, approved way to work with its private data.

Notice also that printSummary has no static. The methods you read in Topic 1.9 had it, but a method that works with one object’s instance variables leaves it out. Topic 3.7 explains what static means.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void printSummary()
    {
        System.out.println("Steps so far: " + steps);
    }
}

public class FirstVoidMethod
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        System.out.println("Checking tracker...");
        tracker.printSummary();
        System.out.println("Done.");
    }
}

Checking tracker...
Steps so far: 4200
Done.

Now vary two things: put an if statement inside the method’s body, and call the method on two different objects. The body of a method can hold any statements you have learned, including selection and loops from Unit 2.

class LibraryCard
{
    private int booksOut;

    public LibraryCard(int startBooks)
    {
        booksOut = startBooks;
    }

    public void printStatus()
    {
        if (booksOut > 3)
        {
            System.out.println(booksOut + " books: limit reached");
        }
        else
        {
            System.out.println(booksOut + " books: OK");
        }
    }
}

public class LibraryCards
{
    public static void main(String[] args)
    {
        LibraryCard ana = new LibraryCard(2);
        LibraryCard ben = new LibraryCard(5);
        System.out.println("Report");
        ben.printStatus();
        ana.printStatus();
    }
}

Report
5 books: limit reached
2 books: OK

ana and ben are separate objects, each with its own booksOut (Topic 3.4). On line 30, ben.printStatus() runs the method with ben’s booksOut, which is 5, so the condition 5 > 3 is true and line 14 runs. On line 31, the very same method runs with ana’s booksOut, which is 2, so the else branch runs. The method was written once, but what it does depends on which object it was called on. The order of output follows the order of the calls in main, not the order the objects were created.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public printSummary()
    {
        System.out.println("Steps so far: " + steps);
    }
}

public class MissingReturnType
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.printSummary();
    }
}

MissingReturnType.java:10: error: invalid method declaration; return type required

int shown = tracker.printSummary();

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void printSummary()
    {
        System.out.println("Steps so far: " + steps);
    }
}

public class TwoTrackers
{
    public static void main(String[] args)
    {
        StepTracker maya = new StepTracker(4200);
        StepTracker leo = new StepTracker(9800);
        leo.printSummary();
        maya.printSummary();
        leo.printSummary();
    }
}

Steps so far: 9800
Steps so far: 4200
Steps so far: 9800

A step tracker that only reports 4,200 steps forever is broken. When you walk, the count has to go up. Could main just add to the variable directly? Try it:

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }
}

public class PrivateAccess
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.steps = tracker.steps + 500;
    }
}

Java refuses: PrivateAccess.java:16: error: steps has private access in StepTracker. As Topic 3.3 explained, private keeps code in other classes from touching the instance variable. That protection is on purpose, but it means the class itself must provide a way to change the value.

In plain words: the class offers a public “change it” button, and anyone who wants the value changed has to press that button. The class decides exactly what pressing it does.

A mutator method (also called a modifier method) is a method that changes the values of an object’s instance variables. A mutator is often a void method, because its job is to change the object, not to hand back an answer.

Most mutators need to know how much to change. Recall from Topic 1.9 that a parameter is a variable in the header that receives the argument’s value when the method is called. A method receives values through its parameters and uses those values to do its job:

public void addSteps(int newSteps)
{
    steps = steps + newSteps;
}

The parameter newSteps holds whatever number the caller passes. The body adds it to the instance variable steps and stores the result back in steps. Because steps belongs to the object, the new value is still there after the method ends. Notice the parameter has a different name from the instance variable; that keeps it clear which one each line means.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void addSteps(int newSteps)
    {
        steps = steps + newSteps;
    }

    public void printSummary()
    {
        System.out.println("Steps so far: " + steps);
    }
}

public class AddSteps
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.addSteps(2500);
        tracker.printSummary();
        tracker.addSteps(800);
        tracker.printSummary();
    }
}

Now vary something: a mutator does not need a parameter if it always makes the same change. Here a reset method sets the count back to 0, and the order of the calls matters.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void addSteps(int newSteps)
    {
        steps = steps + newSteps;
    }

    public void reset()
    {
        steps = 0;
    }

    public void printSummary()
    {
        System.out.println("Steps so far: " + steps);
    }
}

public class ResetSteps
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.addSteps(1000);
        tracker.reset();
        tracker.addSteps(300);
        tracker.printSummary();
    }
}

Steps so far: 300

Line 31 raises steps from 4200 to 5200. Line 32 calls reset, which replaces 5200 with 0 no matter what it was. Line 33 adds 300 to 0. If lines 32 and 33 were swapped, the 300 would be wiped out and the program would print Steps so far: 0. A mutator changes the object’s state at the moment it is called, so later calls start from whatever state earlier calls left behind.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void addSteps(int newSteps)
    {
        newSteps = steps + newSteps;
    }

    public void printSummary()
    {
        System.out.println("Steps so far: " + steps);
    }
}

public class MutatorWrong
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.addSteps(2500);
        tracker.printSummary();
    }
}

class Thermostat
{
    private int temperature;

    public Thermostat(int startTemperature)
    {
        temperature = startTemperature;
    }

    public void raise(int degrees)
    {
        temperature = temperature + degrees;
    }

    public void lower(int degrees)
    {
        temperature = temperature - degrees;
    }

    public void printSetting()
    {
        System.out.println("Set to " + temperature);
    }
}

public class ThermostatTrace
{
    public static void main(String[] args)
    {
        Thermostat hall = new Thermostat(68);
        Thermostat office = new Thermostat(70);
        hall.raise(4);
        office.lower(3);
        hall.lower(1);
        hall.printSetting();
        office.printSetting();
    }
}

Set to 71
Set to 67

class TipJar
{
    private double total;

    public TipJar(double startTotal)
    {
        total = startTotal;
    }

    public void addTip(double tip)
    {
        total = tip;
    }

    public void printTotal()
    {
        System.out.println("Tips: " + total);
    }
}

public class TipJarBug
{
    public static void main(String[] args)
    {
        TipJar jar = new TipJar(10.0);
        jar.addTip(2.5);
        jar.addTip(4.0);
        jar.printTotal();
    }
}

total = total + tip;

Suppose a fitness app needs to know how many steps are left until the daily goal, so it can show a progress bar or work out how many laps remain. A void method could print the number, but printed text goes to the screen, not back into the program. main could not do math with it. The class needs a method that hands back a number.

In Topic 1.9 you used methods like Math.sqrt that return a value, and you saw that Java uses the returned value in place of the call. Now you write the method that does the returning.

A non-void method is a method that returns exactly one value to its caller. Its header puts a return type, such as int, double, or boolean, in the spot where a void method has void. Its body must contain a return statement: the keyword return followed by an expression.

public int stepsToGoal()
{
    return goal - steps;
}

When return goal - steps; runs, Java first evaluates the expression to a single value, then sends that value back to the caller. What travels back is the value itself, a number like 5800, not the variables goal or steps. This is called return by value.

The value must be compatible with the return type, meaning it must be a value Java would let you assign to a variable of that type. The rules are the ones from Topics 1.2 and 1.5: an int value is fine in a method that returns double (Java widens it automatically), but a double value in a method that returns int would lose its decimal part, so Java refuses to compile it.

class StepTracker
{
    private int steps;
    private int goal;

    public StepTracker(int startSteps, int dailyGoal)
    {
        steps = startSteps;
        goal = dailyGoal;
    }

    public int stepsToGoal()
    {
        return goal - steps;
    }
}

public class StepsToGoal
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200, 10000);
        int left = tracker.stepsToGoal();
        System.out.println("Steps left: " + left);
        System.out.println("Laps left: " + tracker.stepsToGoal() / 500);
    }
}

Steps left: 5800
Laps left: 11

Now vary the return type. The same class can have methods that return a double and a boolean.

class StepTracker
{
    private int steps;
    private int goal;

    public StepTracker(int startSteps, int dailyGoal)
    {
        steps = startSteps;
        goal = dailyGoal;
    }

    public double milesWalked()
    {
        return steps / 2000.0;
    }

    public boolean reachedGoal()
    {
        return steps >= goal;
    }
}

public class GoalChecks
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200, 10000);
        double miles = tracker.milesWalked();
        System.out.println(miles);
        if (tracker.reachedGoal())
        {
            System.out.println("Goal met!");
        }
        else
        {
            System.out.println("Keep walking.");
        }
    }
}

2.1
Keep walking.

• milesWalked (lines 12–15) returns steps / 2000.0. Dividing by 2000.0 makes it floating-point division (Topic 1.3), so 4200 / 2000.0 is 2.1, a double, which matches the return type double.
• reachedGoal (lines 17–20) returns steps >= goal. A relational expression produces a boolean (Topic 2.2), so the method returns false here, since 4200 is not at least 10000. No if is needed inside the method: the comparison’s result is the answer.
• Line 30 uses the returned boolean directly as an if condition. Since it is false, the else branch prints Keep walking.

Finally, the widening rule in action. Here length * width is an int, but the method returns double:

class Garden
{
    private int length;
    private int width;

    public Garden(int gardenLength, int gardenWidth)
    {
        length = gardenLength;
        width = gardenWidth;
    }

    public double area()
    {
        return length * width;
    }
}

public class GardenArea
{
    public static void main(String[] args)
    {
        Garden plot = new Garden(3, 4);
        System.out.println(plot.area());
    }
}

It prints 12.0. Java computes 3 × 4 = 12 as an int, then widens it to 12.0 to match the return type, just as double area = 12; would.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public int milesWalked()
    {
        return steps / 2000.0;
    }
}

public class LossyReturn
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        System.out.println(tracker.milesWalked());
    }
}

LossyReturn.java:12: error: incompatible types: possible lossy conversion from double to int

class PizzaOrder
{
    private int pizzas;

    public PizzaOrder(int pizzaCount)
    {
        pizzas = pizzaCount;
    }

    public int slices()
    {
        return pizzas * 8;
    }

    public double totalCost()
    {
        return pizzas * 12.5;
    }
}

public class PizzaTrace
{
    public static void main(String[] args)
    {
        PizzaOrder order = new PizzaOrder(3);
        int perPerson = order.slices() / 5;
        System.out.println(perPerson);
        System.out.println(order.totalCost() + 4);
    }
}

4
41.5

Private instance variables protect an object’s data from careless changes, but sometimes other code legitimately needs to know a value. A leaderboard needs each tracker’s step count; a report needs the goal. main cannot read tracker.steps directly (that is the same private access error from 3.5.2). How can other classes look at a value without being able to change it?

In plain words: the class answers questions about itself. You ask, “What are your steps?” and it tells you the number. Telling you the number does not give you the power to change it, the same way a friend telling you their locker combination does not move the dial.

An accessor method is a method that lets code in other classes obtain a copy of an instance variable’s value. An accessor is always a non-void method, because its whole job is to return something. By convention its name is get followed by the variable’s name, so accessors are often called “getters”:

public int getSteps()
{
    return steps;
}

Because of return by value (3.5.3), return steps; sends back the number stored in steps, not the variable itself. The caller gets its own copy of that number. (Accessors can also report class variables, which belong to a whole class instead of one object; those arrive in Topic 3.7.)

Accessors and mutators are easy to mix up, so compare them side by side:

class StepTracker
{
    private int steps;
    private int goal;

    public StepTracker(int startSteps, int dailyGoal)
    {
        steps = startSteps;
        goal = dailyGoal;
    }

    public int getSteps()
    {
        return steps;
    }

    public int getGoal()
    {
        return goal;
    }

    public void addSteps(int newSteps)
    {
        steps = steps + newSteps;
    }
}

public class Accessors
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200, 10000);
        System.out.println(tracker.getSteps());
        tracker.addSteps(3000);
        System.out.println(tracker.getSteps());
        System.out.println(tracker.getGoal() - tracker.getSteps());
    }
}

4200
7200
2800

Now vary it: what happens if the caller changes the copy it received?

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public int getSteps()
    {
        return steps;
    }
}

public class AccessorCopy
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        int mySteps = tracker.getSteps();
        mySteps = 0;
        System.out.println(mySteps);
        System.out.println(tracker.getSteps());
    }
}

0
4200

Line 21 stores the returned copy, 4200, in a new variable mySteps that belongs to main. Line 22 sets mySteps to 0. That changes only main’s variable. The object’s steps is a different variable in a different place, and it still holds 4200, which line 24 confirms. This is exactly why accessors are safe: they share a value, not access.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public int getSteps()
    {
        return steps;
    }
}

public class AccessorAssign
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.getSteps() += 500;
    }
}

AccessorAssign.java:21: error: unexpected type
  required: variable
  found:    value

class PiggyBank
{
    private double balance;

    public PiggyBank(double startBalance)
    {
        balance = startBalance;
    }

    public double getBalance()
    {
        return balance;
    }
}

public class PiggyCopy
{
    public static void main(String[] args)
    {
        PiggyBank bank = new PiggyBank(12.0);
        double money = bank.getBalance();
        money = money - 5.0;
        System.out.println(money);
        System.out.println(bank.getBalance());
    }
}

7.0
12.0

A tracker awards a badge: level 3 for at least 10,000 steps, level 2 for at least 5,000, and level 1 otherwise. As soon as the method knows the answer, it should stop and report it. Checking the other cases would be wasted work, and might even pick the wrong level.

In Topic 1.9 you saw that when a method finishes, control returns to the point of the call. The return keyword is how a method finishes on purpose, at any point you choose.

The return keyword sends the flow of control back to the place where the method was called, immediately. Two consequences follow:

• Nothing after it runs. Any statement that comes after a return statement in the same run of the method is never executed.
• It exits an if or a loop too. If a return statement runs inside an if statement or a loop, it does not just leave that statement; it ends the whole method on the spot. A loop does not finish its remaining iterations.

A void method can use return as well, written with no value: return;. It simply means “stop here.” (The same is true inside a constructor, though it is rarely needed there.)

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public int badgeLevel()
    {
        if (steps >= 10000)
        {
            return 3;
        }
        if (steps >= 5000)
        {
            return 2;
        }
        return 1;
    }
}

public class BadgeLevel
{
    public static void main(String[] args)
    {
        StepTracker sam = new StepTracker(7000);
        StepTracker kim = new StepTracker(12000);
        StepTracker raj = new StepTracker(2500);
        System.out.println(sam.badgeLevel());
        System.out.println(kim.badgeLevel());
        System.out.println(raj.badgeLevel());
    }
}

2
3
1

Now vary it: put the return inside a loop. extraDaysNeeded checks day by day whether walking stepsPerDay more each day for that many days reaches the goal, for up to a week.

class StepTracker
{
    private int steps;
    private int goal;

    public StepTracker(int startSteps, int dailyGoal)
    {
        steps = startSteps;
        goal = dailyGoal;
    }

    public int extraDaysNeeded(int stepsPerDay)
    {
        for (int day = 1; day <= 7; day++)
        {
            if (steps + day * stepsPerDay >= goal)
            {
                return day;
            }
        }
        return -1;
    }
}

public class DaysToGoal
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200, 10000);
        System.out.println(tracker.extraDaysNeeded(2000));
        System.out.println(tracker.extraDaysNeeded(500));
    }
}

3
-1

Call on line 30, stepsPerDay is 2000, steps is 4200, goal is 10000:

The loop was set up to run up to 7 times, but the return on line 18 stops it after 3 and exits the method. Days 4 to 7 are never checked, and return -1; on line 21 never runs.

Call on line 31, stepsPerDay is 500: even on day 7, 4200 + 3500 = 7700 is short of the goal, so the if is false every time. The loop ends normally after day reaches 8, and control falls through to line 21, which returns −1. Using a value that could never be a real answer (no one needs −1 days) is a common way to report “not found”.

A void method can stop early with return;. Here addSteps refuses a negative number of steps:

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void addSteps(int newSteps)
    {
        if (newSteps < 0)
        {
            System.out.println("Ignored: " + newSteps);
            return;
        }
        steps = steps + newSteps;
        System.out.println("Added: " + newSteps);
    }

    public int getSteps()
    {
        return steps;
    }
}

public class EarlyVoidReturn
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200);
        tracker.addSteps(-300);
        tracker.addSteps(600);
        System.out.println(tracker.getSteps());
    }
}

Ignored: -300
Added: 600
4800

On line 32, newSteps is −300, so the if is true: line 14 prints, and return; on line 15 ends the method. Lines 17 and 18 are skipped, so steps stays 4200. On line 33, newSteps is 600, the if is false, and lines 17 and 18 run, making steps 4800.

class StepTracker
{
    private int steps;
    private int goal;

    public StepTracker(int startSteps, int dailyGoal)
    {
        steps = startSteps;
        goal = dailyGoal;
    }

    public int stepsToGoal()
    {
        return goal - steps;
        System.out.println("Calculated steps left");
    }
}

public class Unreachable
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200, 10000);
        System.out.println(tracker.stepsToGoal());
    }
}

Unreachable.java:15: error: unreachable statement

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public int badgeLevel()
    {
        if (steps >= 10000)
        {
            return 3;
        }
        if (steps >= 5000)
        {
            return 2;
        }
    }
}

public class MissingReturn
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(7000);
        System.out.println(tracker.badgeLevel());
    }
}

MissingReturn.java:20: error: missing return statement

class SavingsJar
{
    private int dollars;

    public SavingsJar(int startDollars)
    {
        dollars = startDollars;
    }

    public int weeksUntil(int target, int weekly)
    {
        int total = dollars;
        int week = 0;
        while (week < 10)
        {
            if (total >= target)
            {
                return week;
            }
            week++;
            total = total + weekly;
        }
        return 10;
    }
}

public class SavingsTrace
{
    public static void main(String[] args)
    {
        SavingsJar jar = new SavingsJar(15);
        System.out.println(jar.weeksUntil(40, 10));
        System.out.println(jar.weeksUntil(10, 5));
    }
}

3
0

class Quiz
{
    private int score;

    public Quiz(int startScore)
    {
        score = startScore;
    }

    public void addBonus(int bonus)
    {
        if (score + bonus > 100)
        {
            score = 100;
            return;
        }
        score = score + bonus;
        System.out.println("Bonus added");
    }

    public int getScore()
    {
        return score;
    }
}

public class ScoreCheck
{
    public static void main(String[] args)
    {
        Quiz quiz = new Quiz(95);
        quiz.addBonus(10);
        System.out.println(quiz.getScore());
    }
}

When you hand a method a variable, can the method change that variable? In 3.5.2 a mutator changed the object’s instance variable, and the change lasted. A parameter is also a variable the method can assign to. So if a method changes its parameter, does the caller’s variable change too?

Topic 1.9 answered this for the methods you read there: Java uses call by value. The same rule holds for every method you write in a class.

In plain words: when you call a method, Java photocopies the argument’s value and gives the copy to the parameter. The method can scribble on its copy all it likes; your original is untouched.

When an argument is a primitive value, such as an int, double, or boolean, the parameter is initialized with a copy of that value. The parameter and the caller’s variable are two separate variables that happen to start with the same value. Changing the parameter has no effect on the argument.

This is different from changing an instance variable. An instance variable belongs to the object and outlives the call. A parameter belongs to one run of the method and disappears when the method ends.

class PiggyBank
{
    private double balance;

    public PiggyBank(double startBalance)
    {
        balance = startBalance;
    }

    public void deposit(double amount)
    {
        balance = balance + amount;
        amount = 0;
    }

    public double getBalance()
    {
        return balance;
    }
}

public class DepositCopy
{
    public static void main(String[] args)
    {
        PiggyBank bank = new PiggyBank(5.0);
        double cash = 20.0;
        bank.deposit(cash);
        System.out.println(cash);
        System.out.println(bank.getBalance());
    }
}

20.0
25.0

Now vary it: let a loop count the parameter down to 0. walkLaps adds 400 steps per lap.

class StepTracker
{
    private int steps;

    public StepTracker(int startSteps)
    {
        steps = startSteps;
    }

    public void walkLaps(int laps)
    {
        while (laps > 0)
        {
            steps = steps + 400;
            laps--;
        }
    }

    public int getSteps()
    {
        return steps;
    }
}

public class WalkLaps
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(0);
        int plannedLaps = 3;
        tracker.walkLaps(plannedLaps);
        System.out.println(plannedLaps);
        System.out.println(tracker.getSteps());
    }
}

3
1200

Inside the method, laps starts as a copy of 3. The loop runs while laps > 0, adding 400 to steps and decreasing laps each time: 3 → 2 → 1 → 0. After three iterations laps is 0, the loop ends, and steps is 1200. Back in main, plannedLaps still holds 3, because the loop counted down the copy, not the original. Using a parameter as a counter is perfectly safe for exactly this reason.

class StepTracker
{
    private int steps;
    private int goal;

    public StepTracker(int startSteps, int dailyGoal)
    {
        steps = startSteps;
        goal = dailyGoal;
    }

    public void findStepsLeft(int result)
    {
        result = goal - steps;
    }
}

public class ParameterAsResult
{
    public static void main(String[] args)
    {
        StepTracker tracker = new StepTracker(4200, 10000);
        int left = 0;
        tracker.findStepsLeft(left);
        System.out.println(left);
    }
}

Object references passed as arguments follow the same copying rule, but with an extra twist that Topic 3.6 covers.

class Fundraiser
{
    private int raised;

    public Fundraiser(int startRaised)
    {
        raised = startRaised;
    }

    public void collect(int donation)
    {
        donation = donation * 2;
        raised = raised + donation;
    }

    public int getRaised()
    {
        return raised;
    }
}

public class CopyTrace
{
    public static void main(String[] args)
    {
        Fundraiser drive = new Fundraiser(100);
        int gift = 25;
        drive.collect(gift);
        drive.collect(gift);
        System.out.println(gift);
        System.out.println(drive.getRaised());
    }
}

25
200

A phone battery class uses every kind of method from this chapter: an accessor, a void mutator, and a mutator that also returns an answer. The use method spends charge only if there is enough, and it returns true or false to say whether it worked. A mutator is often void, but not always; use changes the object and reports back.

class Battery
{
    private int percent;

    public Battery(int startPercent)
    {
        percent = startPercent;
    }

    public int getPercent()
    {
        return percent;
    }

    public void charge(int amount)
    {
        percent = percent + amount;
        if (percent > 100)
        {
            percent = 100;
        }
    }

    public boolean use(int amount)
    {
        if (amount > percent)
        {
            return false;
        }
        percent = percent - amount;
        return true;
    }
}

public class BatteryDemo
{
    public static void main(String[] args)
    {
        Battery phone = new Battery(30);
        int videoCost = 45;
        System.out.println(phone.use(videoCost));
        phone.charge(80);
        System.out.println(phone.getPercent());
        System.out.println(phone.use(videoCost));
        System.out.println(phone.getPercent() + " " + videoCost);
    }
}

false
100
true
55 45

The Watch Out boxes explained each mistake. This table is a lookup for the compiler messages you met, so you can match an error to its cause quickly. Exact wording can vary slightly between Java versions.

• Methods written inside a class give its objects behaviors. They can use the class’s private instance variables by name, and a call runs the method with the instance variables of the object before the dot.
• A void method has void in its header and returns nothing, so its call is a statement on its own. A non-void method has a return type instead, and its return statement evaluates an expression and sends back one value, which must be compatible with the return type (return by value).
• A mutator method changes an object’s instance variables, using values received through its parameters; mutators are often void. An accessor method is non-void and returns a copy of an instance variable’s value, so callers can read it but not change it.
• A return statement ends the method immediately and sends control back to the caller, even from inside an if or a loop. Code after it does not run, and a non-void method must return a value on every path.
• A primitive argument’s value is copied into its parameter. Changing the parameter never changes the caller’s variable; only changes to instance variables last after the method ends.

public int getVisits()               // returns visits
public void checkIn()                // adds 1 to visits
public boolean renew(int months)     // adds months to monthsLeft and returns true
public double costPerVisit()         // returns 40.0 / visits; changes nothing

class Bakery
{
    private int muffins;

    public Bakery(int startMuffins)
    {
        muffins = startMuffins;
    }

    public int sell(int wanted)
    {
        if (wanted > muffins)
        {
            wanted = muffins;
        }
        muffins = muffins - wanted;
        return wanted;
    }

    public int getMuffins()
    {
        return muffins;
    }
}

public class BakeryReview
{
    public static void main(String[] args)
    {
        Bakery shop = new Bakery(10);
        int order = 4;
        int sold = shop.sell(order);
        System.out.println(sold + " " + order);
        order = 9;
        sold = shop.sell(order);
        System.out.println(sold + " " + order);
        System.out.println(shop.getMuffins());
    }
}

4 4
6 9
0

class MovieReview
{
    private int score;

    public MovieReview(int reviewScore)
    {
        score = reviewScore;
    }

    public int stars()
    {
        if (score >= 90)
        {
            return 5;
        }
        else if (score >= 70)
        {
            return 4;
        }
        else if (score >= 50)
        {
            return 3;
        }
    }
}

public class StarsMissingReturn
{
    public static void main(String[] args)
    {
        MovieReview review = new MovieReview(75);
        System.out.println(review.stars());
    }
}

        else if (score >= 50)
        {
            return 3;
        }
        return 1;
    }

class CountdownTimer
{
    private int seconds;

    public CountdownTimer(int startSeconds)
    {
        seconds = startSeconds;
    }

    public int tickUntil(int alarmAt)
    {
        int ticks = 0;
        while (seconds > 0)
        {
            seconds = seconds - 5;
            ticks++;
            if (seconds <= alarmAt)
            {
                return ticks;
            }
            System.out.println("tick " + seconds);
        }
        System.out.println("timer ended");
        return ticks;
    }

    public int getSeconds()
    {
        return seconds;
    }
}

public class TimerReview
{
    public static void main(String[] args)
    {
        CountdownTimer timer = new CountdownTimer(30);
        System.out.println(timer.tickUntil(18));
        System.out.println(timer.getSeconds());
        System.out.println(timer.tickUntil(-1));
    }
}

tick 25
tick 20
3
15
tick 10
tick 5
tick 0
timer ended
3

public void printTotal()
{
    System.out.println(price * quantity);
}

public double getTotal()
{
    return price * quantity;
}

class Gradebook
{
    private int totalPoints;
    private int quizCount;

    public Gradebook()
    {
        totalPoints = 0;
        quizCount = 0;
    }

    public void addQuiz(int points)
    {
        totalPoints = totalPoints + points;
        quizCount++;
    }

    public double average()
    {
        return totalPoints / quizCount;
    }
}

public class AverageBug
{
    public static void main(String[] args)
    {
        Gradebook book = new Gradebook();
        book.addQuiz(9);
        book.addQuiz(10);
        System.out.println(book.average());
    }
}

        return (double) totalPoints / quizCount;

Check each statement. If the answer is “not yet,” reread the linked subsection.

• I can read a void method inside a class and explain why its call is a statement on its own. Reread
• I can explain what a mutator method does and trace how it changes an object over several calls. Reread
• I can tell whether a return statement matches its method's return type and trace what the call is replaced by. Reread
• I can explain what an accessor method is and why changing its returned value does not change the object. Reread
• I can find exactly where a method stops when a return statement runs inside an if statement or a loop. Reread
• I can explain why changing a primitive parameter never changes the caller's variable. Reread