Class Variables and Methods

A club wants its Member class to keep track of how many members have joined. Where should that number live? It cannot be an ordinary instance variable. Recall from Topic 3.3 that every object gets its own copy of each instance variable. If every Member object had its own count, each one would only know about itself. The count is not a fact about Ana or about Ben; it is a fact about the club as a whole.

Java’s answer is a variable that belongs to the class instead of to any one object. There is exactly one copy of it, no matter how many objects exist, and every object of the class uses that same copy. Think of a classroom whiteboard: each student has their own notebook (an instance variable), but there is only one whiteboard, and when one student writes on it, everyone sees the change. The comparison has a limit: a whiteboard sits in one room, while a Java class variable can be reached by any code that is allowed to see it, as you will learn in 3.7.2.

A class variable is a variable that belongs to the class itself, so all objects of the class share a single copy of it. You make one by writing the keyword static before the variable’s type in the declaration. You met static in Topic 1.10 as the word that marks a class method; on a variable it means the same thing: “this belongs to the class.”

private static int memberCount = 0;

Why is the starting value written in the declaration instead of in the constructor? A constructor runs once for each new object. If the constructor set memberCount = 0, every new member would wipe out the count. A class variable is set up once, when the class is first used, so its starting value goes on the declaration line.

class Member
{
    private String name;
    private static int memberCount = 0;

    public Member(String memberName)
    {
        name = memberName;
        memberCount++;
    }

    public int getMemberCount()
    {
        return memberCount;
    }
}

public class MemberCount
{
    public static void main(String[] args)
    {
        Member ana = new Member("Ana");
        System.out.println(ana.getMemberCount());
        Member ben = new Member("Ben");
        System.out.println(ana.getMemberCount());
        Member cy = new Member("Cy");
        System.out.println(ana.getMemberCount());
        System.out.println(cy.getMemberCount());
    }
}

Member class (one shared copy):   memberCount = 3

ana --> [ name = "Ana" ]
ben --> [ name = "Ben" ]
cy  --> [ name = "Cy"  ]

1
2
3
3

Now vary the example so an instance variable and a class variable change side by side. Each Player keeps their own points, and the team keeps one shared teamPoints:

class Player
{
    private int points;
    private static int teamPoints = 0;

    public Player()
    {
        points = 0;
    }

    public void scorePoints(int amount)
    {
        points += amount;
        teamPoints += amount;
    }

    public int getPoints()
    {
        return points;
    }

    public int getTeamPoints()
    {
        return teamPoints;
    }
}

public class TeamScore
{
    public static void main(String[] args)
    {
        Player maya = new Player();
        Player leo = new Player();
        maya.scorePoints(3);
        leo.scorePoints(2);
        maya.scorePoints(4);
        System.out.println(maya.getPoints());
        System.out.println(leo.getPoints());
        System.out.println(leo.getTeamPoints());
    }
}

scorePoints (lines 11 to 15) adds the same amount to both variables, but they behave differently:

7
2
9

Each call changes only the points of the object it was called on, but every call changes the single teamPoints. That is why leo.getTeamPoints() reports 9, including the 7 points Maya scored.

class Member
{
    private String name;
    private int memberCount = 0;

    public Member(String memberName)
    {
        name = memberName;
        memberCount++;
    }

    public int getMemberCount()
    {
        return memberCount;
    }
}

public class MemberNoStatic
{
    public static void main(String[] args)
    {
        Member ana = new Member("Ana");
        System.out.println(ana.getMemberCount());
        Member ben = new Member("Ben");
        System.out.println(ana.getMemberCount());
        Member cy = new Member("Cy");
        System.out.println(ana.getMemberCount());
        System.out.println(cy.getMemberCount());
    }
}

1
1
1
1

Where in a class each kind of variable may be used is the subject of Topic 3.8.

class Bike
{
    private int rides;
    private static int totalRides = 0;

    public Bike(int startingRides)
    {
        rides = startingRides;
        totalRides += startingRides;
    }

    public void ride()
    {
        rides++;
        totalRides++;
    }

    public int getRides()
    {
        return rides;
    }

    public int getTotalRides()
    {
        return totalRides;
    }
}

public class BikeRides
{
    public static void main(String[] args)
    {
        Bike red = new Bike(5);
        Bike blue = new Bike(0);
        blue.ride();
        red.ride();
        blue.ride();
        System.out.println(red.getRides());
        System.out.println(blue.getRides());
        System.out.println(red.getTotalRides());
    }
}

6
2
8

So far the shared count was private, so code outside the class needed an object to ask for it. But a class variable does not belong to any object. How should code in another class, such as main, refer to it directly?

Use the same pattern you used for class methods in Topic 1.10: the class name, the dot operator, then the variable name. If a class variable is declared public, any class can reach it as ClassName.variableName. The class name is the natural thing to write because the variable is attached to the class, not to an object. You have already done this once: in Topic 1.5 you used Integer.MAX_VALUE, which is a public class variable of Java’s Integer class.

class Raffle
{
    public static int ticketsSold = 0;
    private String buyer;

    public Raffle(String buyerName)
    {
        buyer = buyerName;
        ticketsSold++;
    }
}

public class RaffleSales
{
    public static void main(String[] args)
    {
        System.out.println(Raffle.ticketsSold);
        Raffle first = new Raffle("Jo");
        Raffle second = new Raffle("Sam");
        System.out.println(Raffle.ticketsSold);
        Raffle.ticketsSold = 0;
        System.out.println(Raffle.ticketsSold);
    }
}

0
2
0

Now vary the access. Here ticketsSold is private and main tries the same read:

class Raffle
{
    private static int ticketsSold = 0;
    private String buyer;

    public Raffle(String buyerName)
    {
        buyer = buyerName;
        ticketsSold++;
    }
}

public class RafflePrivate
{
    public static void main(String[] args)
    {
        System.out.println(Raffle.ticketsSold);
        Raffle first = new Raffle("Jo");
        Raffle second = new Raffle("Sam");
        System.out.println(Raffle.ticketsSold);
        System.out.println(Raffle.ticketsSold);
    }
}

The compiler stops at line 17:

RafflePrivate.java:17: error: ticketsSold has private access in Raffle

The class name and dot are the right form, but private still means only code inside Raffle may touch the variable. Writing the class name never gets around private. To share a private class variable safely, the class provides a method that returns it. You will write that kind of method, one that needs no object at all, in 3.7.4.

class Raffle
{
    public static int ticketsSold = 0;
    private String buyer;

    public Raffle(String buyerName)
    {
        buyer = buyerName;
        ticketsSold++;
    }
}

public class RaffleNoClassName
{
    public static void main(String[] args)
    {
        Raffle first = new Raffle("Jo");
        System.out.println(ticketsSold);
    }
}

        System.out.println(Raffle.ticketsSold);

class Museum
{
    public static int visitors = 0;
    private String exhibit;

    public Museum(String exhibitName)
    {
        exhibit = exhibitName;
    }

    public void enter()
    {
        visitors++;
    }
}

public class VisitorCount
{
    public static void main(String[] args)
    {
        Museum dinosaurs = new Museum("Dinosaurs");
        Museum space = new Museum("Space");
        dinosaurs.enter();
        space.enter();
        space.enter();
        System.out.println(Museum.visitors);
    }
}

Some values should never change while a program runs: the number of slices in a pizza, the passing score on a test, a student’s ID number. If such a value is stored in an ordinary variable, a careless line like the one in 3.7.2 could change it, and every calculation after that would be wrong. You want Java itself to refuse the change.

That is what the keyword final does. A final variable is a variable whose value cannot be modified once it has been given. Any statement that tries to assign it a new value is a compile error, so the mistake is caught before the program ever runs.

final combines naturally with static. A value like “8 slices per pizza” is the same for every pizza order, so there is no reason for each object to store its own copy; one shared copy is enough. And because it can never change, it is safe to make public: nobody can damage it. A public static final variable is called a class constant. By custom, Java programmers write constant names in all capital letters with underscores between words, such as SLICES_PER_PIZZA, so readers can spot them. Integer.MAX_VALUE from Topic 1.5 is a class constant.

public static final int SLICES_PER_PIZZA = 8;

Read it as: anyone may use it (public), there is one copy for the class (static), it cannot change (final), it is an int named SLICES_PER_PIZZA, and its value is 8.

class PizzaOrder
{
    public static final int SLICES_PER_PIZZA = 8;
    private int pizzas;

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

    public int getSlices()
    {
        return pizzas * SLICES_PER_PIZZA;
    }
}

public class PizzaParty
{
    public static void main(String[] args)
    {
        System.out.println(PizzaOrder.SLICES_PER_PIZZA);
        PizzaOrder party = new PizzaOrder(4);
        System.out.println(party.getSlices());
    }
}

8
32

final is not only for class variables; it can go on any variable. Vary the example: here final is on an instance variable. Each student gets their own ID, set once in the constructor, and it should never change, while a nickname may change any time.

class Student
{
    private final int idNumber;
    private String nickname;

    public Student(int id, String startingNickname)
    {
        idNumber = id;
        nickname = startingNickname;
    }

    public void setNickname(String newNickname)
    {
        nickname = newNickname;
    }

    public int getIdNumber()
    {
        return idNumber;
    }

    public String getNickname()
    {
        return nickname;
    }
}

public class StudentId
{
    public static void main(String[] args)
    {
        Student kim = new Student(4417, "Kimmy");
        Student raj = new Student(5280, "Raj");
        kim.setNickname("K");
        System.out.println(kim.getNickname());
        System.out.println(kim.getIdNumber());
        System.out.println(raj.getIdNumber());
    }
}

Line 3 declares idNumber as private final int with no value. The constructor gives it one on line 8, once per object. Kim’s nickname changes on line 34, but her ID stays 4417, and Raj has his own ID, 5280, because idNumber is not static:

K
4417
5280

If the class had a method such as setIdNumber that tried idNumber = newId;, the class would not compile: Java reports cannot assign a value to final variable idNumber. The same goes for a final local variable. In this code the third line fails to compile with cannot assign a value to final variable minutesPerHour:

final int minutesPerHour = 60;
int hours = 3;
minutesPerHour = 90;
System.out.println(hours * minutesPerHour);

Remove that line and the code prints 180.

class PizzaOrder
{
    public static final int SLICES_PER_PIZZA = 8;
    private int pizzas;

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

    public int getSlices()
    {
        return pizzas * SLICES_PER_PIZZA;
    }
}

public class FinalChange
{
    public static void main(String[] args)
    {
        PizzaOrder.SLICES_PER_PIZZA = 10;
        PizzaOrder party = new PizzaOrder(4);
        System.out.println(party.getSlices());
    }
}

FinalChange.java:21: error: cannot assign a value to static final variable SLICES_PER_PIZZA

class Student
{
    private final int idNumber;
    private String nickname;

    public Student(int id, String startingNickname)
    {
        idNumber = id;
        nickname = startingNickname;
    }

    public void setNickname(String newNickname)
    {
        nickname = newNickname;
    }

    public void setIdNumber(int newId)
    {
        idNumber = newId;
    }
}

public class StudentIdChange
{
    public static void main(String[] args)
    {
        Student kim = new Student(4417, "Kimmy");
        kim.setNickname("K");
        kim.setIdNumber(1000);
    }
}

In 3.7.2, making the ticket count private meant main could not read it. An instance accessor would work, but only if you already had a ticket object to call it on, and the count is not about any one ticket. You need a method that, like the variable, belongs to the class.

In Topic 1.10 you called class methods such as Math.sqrt and wrote a few in the class that holds main. Now you will write them in your own object classes. A class method is written like any method from Topic 3.5, with static added before the return type:

public static int getTicketsSold()

A class method may use the class’s class variables, reading them or changing them, and may call the class’s other class methods. Everything it uses belongs to the class, so no object is needed to run it. From another class you call it as ClassName.methodName(arguments); inside its own class the class name may be left off, exactly as in Topic 1.10.

class Raffle
{
    private static int ticketsSold = 0;
    private String buyer;

    public Raffle(String buyerName)
    {
        buyer = buyerName;
        ticketsSold++;
    }

    public static int getTicketsSold()
    {
        return ticketsSold;
    }

    public static void resetSales()
    {
        ticketsSold = 0;
    }
}

public class RaffleReport
{
    public static void main(String[] args)
    {
        System.out.println(Raffle.getTicketsSold());
        Raffle first = new Raffle("Jo");
        Raffle second = new Raffle("Sam");
        Raffle third = new Raffle("Lee");
        System.out.println(Raffle.getTicketsSold());
        Raffle.resetSales();
        System.out.println(Raffle.getTicketsSold());
    }
}

0
3
0

Now vary it: a class with no instance variables at all, where one class method calls another. GradeScale works like Math: it is a toolbox of class methods.

class GradeScale
{
    public static final int PASSING = 70;

    public static double percent(int earned, int possible)
    {
        return 100.0 * earned / possible;
    }

    public static boolean passed(int earned, int possible)
    {
        return percent(earned, possible) >= PASSING;
    }
}

public class GradeCheck
{
    public static void main(String[] args)
    {
        System.out.println(GradeScale.percent(45, 50));
        System.out.println(GradeScale.passed(45, 50));
        System.out.println(GradeScale.passed(30, 50));
    }
}

• percent (lines 5 to 8) computes 100.0 * earned / possible. Starting with 100.0 makes the arithmetic double, so no integer division happens.
• passed (lines 10 to 13) calls another class method, percent, without a class name because both are in GradeScale. It compares the result with the class constant PASSING.

Line 20 prints 100.0 * 45 / 50, which is 4500.0 / 50, or 90.0. Line 21 calls passed(45, 50): percent returns 90.0, and 90.0 >= 70 is true. Line 22: percent(30, 50) is 60.0, and 60.0 >= 70 is false.

90.0
true
false

class Raffle
{
    private static int ticketsSold = 0;
    private String buyer;

    public Raffle(String buyerName)
    {
        buyer = buyerName;
        ticketsSold++;
    }

    public int getTicketsSold()
    {
        return ticketsSold;
    }

    public static void resetSales()
    {
        ticketsSold = 0;
    }
}

public class RaffleMissingStatic
{
    public static void main(String[] args)
    {
        System.out.println(Raffle.getTicketsSold());
        Raffle first = new Raffle("Jo");
        Raffle second = new Raffle("Sam");
        Raffle third = new Raffle("Lee");
        System.out.println(Raffle.getTicketsSold());
        Raffle.resetSales();
        System.out.println(Raffle.getTicketsSold());
    }
}

RaffleMissingStatic.java:27: error: non-static method getTicketsSold() cannot be referenced from a static context

class Garage
{
    public static final int TOTAL_SPOTS = 5;
    private static int spotsTaken = 0;

    public static void park()
    {
        spotsTaken++;
    }

    public static void leave()
    {
        spotsTaken--;
    }

    public static int spotsOpen()
    {
        return TOTAL_SPOTS - spotsTaken;
    }

    public static boolean isFull()
    {
        return spotsOpen() == 0;
    }
}

public class ParkingLot
{
    public static void main(String[] args)
    {
        Garage.park();
        Garage.park();
        Garage.park();
        Garage.leave();
        System.out.println(Garage.spotsOpen());
        Garage.park();
        Garage.park();
        Garage.park();
        System.out.println(Garage.isFull());
    }
}

3
true

You can call a class method with no objects in existence. That raises a question: what happens if a class method tries to use an instance variable, such as a member’s name? Every Member object has its own name. Whose name should the method use? There might be a hundred members, or none at all.

Java does not guess. Inside a class method there is no particular object, so the method cannot use an instance variable or call an instance method by name alone. The only way to work with an object’s data is to be given an object, through a parameter. Then the method names the object it means: someone.getName() or someone.name. Recall from Topic 3.6 that a method inside a class may even use the private data of a parameter of that same class.

class Member
{
    private String name;

    public Member(String memberName)
    {
        name = memberName;
    }

    public String getName()
    {
        return name;
    }

    public static String describe()
    {
        return "Member: " + name;
    }
}

public class StaticReadsInstance
{
    public static void main(String[] args)
    {
        Member ana = new Member("Ana");
        System.out.println(Member.describe());
    }
}

StaticReadsInstance.java:17: error: non-static variable name cannot be referenced from a static context

class Member
{
    private String name;

    public Member(String memberName)
    {
        name = memberName;
    }

    public String getName()
    {
        return name;
    }

    public static String describe(Member someone)
    {
        return "Member: " + someone.getName();
    }

    public static void rename(Member someone, String newName)
    {
        someone.name = newName;
    }
}

public class MemberDescribe
{
    public static void main(String[] args)
    {
        Member ana = new Member("Ana");
        Member ben = new Member("Ben");
        System.out.println(Member.describe(ana));
        Member.rename(ben, "Benji");
        System.out.println(Member.describe(ben));
    }
}

Member: Ana
Member: Benji

Now vary the number of objects. A class method can receive two objects of its class and compare them:

class Player
{
    private String name;
    private int points;

    public Player(String playerName, int startingPoints)
    {
        name = playerName;
        points = startingPoints;
    }

    public String getName()
    {
        return name;
    }

    public static Player higherScorer(Player first, Player second)
    {
        if (first.points >= second.points)
        {
            return first;
        }
        return second;
    }
}

public class HigherScorer
{
    public static void main(String[] args)
    {
        Player maya = new Player("Maya", 12);
        Player leo = new Player("Leo", 15);
        Player winner = Player.higherScorer(maya, leo);
        System.out.println(winner.getName());
    }
}

higherScorer reads first.points and second.points (both allowed, since the parameters are Players and the method is in Player). On line 33, first refers to Maya (12) and second to Leo (15). 12 >= 15 is false, so line 23 returns the reference in second, Leo’s object, and main prints:

Leo

This also explains something you have done since Unit 1. main is a class method, so it has no object of its own; that is why it always makes an object first and then calls instance methods on it, like ana.getMemberCount(). Topic 3.9 adds a keyword for referring to the current object inside instance methods and constructors; class methods have no current object for it to refer to.

The reverse direction has no such limit: instance methods and constructors may use class variables freely, as Member’s constructor did with memberCount.

class Thermostat
{
    public static final int MAX_COMFORT = 76;
    private int temperature;

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

    public static boolean isTooHot()
    {
        return temperature > MAX_COMFORT;
    }
}

public class ThermostatBug
{
    public static void main(String[] args)
    {
        Thermostat kitchen = new Thermostat(80);
        System.out.println(Thermostat.isTooHot());
    }
}

    public static boolean isTooHot(Thermostat room)
    {
        return room.temperature > MAX_COMFORT;
    }

        System.out.println(Thermostat.isTooHot(kitchen));

A food truck numbers its orders starting at 101. Each Order remembers its own number and cost, the class keeps the next number to hand out and the number of orders placed, and every order pays the same delivery fee.

class Order
{
    public static final double DELIVERY_FEE = 2.5;
    private static int nextNumber = 101;
    private static int ordersPlaced = 0;

    private final int number;
    private double foodCost;

    public Order(double cost)
    {
        foodCost = cost;
        number = nextNumber;
        nextNumber++;
        ordersPlaced++;
    }

    public int getNumber()
    {
        return number;
    }

    public double getTotal()
    {
        return foodCost + DELIVERY_FEE;
    }

    public static int getOrdersPlaced()
    {
        return ordersPlaced;
    }

    public static Order larger(Order first, Order second)
    {
        if (first.getTotal() >= second.getTotal())
        {
            return first;
        }
        return second;
    }
}

public class OrderNumbers
{
    public static void main(String[] args)
    {
        System.out.println(Order.getOrdersPlaced());
        Order tacos = new Order(12.0);
        Order salad = new Order(8.5);
        Order pasta = new Order(15.25);
        System.out.println(Order.getOrdersPlaced());
        System.out.println(salad.getNumber());
        System.out.println(salad.getTotal());
        Order biggest = Order.larger(tacos, pasta);
        System.out.println(biggest.getNumber());
        System.out.println(Order.DELIVERY_FEE);
    }
}

Sort the variables first:

The constructor (lines 10 to 16) copies the shared nextNumber into this order’s number, then moves the shared counter forward, so the next order gets the next number. Trace main:

On line 54, the class method larger receives two orders. It cannot use getTotal() by name alone, so it calls it on each parameter: tacos totals 14.5 and pasta totals 17.75. 14.5 >= 17.75 is false, so it returns second, the pasta order, whose number is 103.

0
3
102
11.0
103
2.5

Every idea from the chapter appears: shared class variables (nextNumber, ordersPlaced) changed by the constructor, a public class constant read with the class name, a final instance variable set once, a class method that reads a class variable, and a class method that works on objects only through its parameters.

The Watch Out boxes explain each mistake. This table is a lookup for the compiler messages you will see in this topic (wording can vary slightly between JDK versions).

A counter declared without static gives no message at all: it compiles and counts only to 1.

• A class variable is declared with static before its type. It belongs to the class, so every object shares one copy, and it exists even before any object is made. Give it its starting value in the declaration, not in the constructor.
• A public class variable is used from another class as ClassName.variableName. Inside its own class, its name alone is enough. Data is still usually kept private.
• A final variable cannot be changed after it gets its value. A public static final variable is a class constant, written in capital letters, such as Integer.MAX_VALUE.
• A class method has static in its header, is called through the class name with no object, and can read and change class variables and call other class methods.
• A class method cannot use instance variables or instance methods by name alone, because there is no current object. Pass it an object through a parameter and work through that object. Instance methods and constructors may always use class variables.

class Visit
{
    private static int visitCount = 0;
    private static int totalPeople = 0;
    private int groupSize;

    public Visit(int people)
    {
        groupSize = people;
        visitCount++;
        totalPeople += people;
    }

    public static double averageGroup()
    {
        return (double) totalPeople / visitCount;
    }

    public static int getVisitCount()
    {
        return visitCount;
    }
}

public class GroupVisits
{
    public static void main(String[] args)
    {
        for (int i = 1; i <= 4; i++)
        {
            Visit v = new Visit(i * 2);
        }
        System.out.println(Visit.getVisitCount());
        System.out.println(Visit.averageGroup());
    }
}

4
5.0

class Badge
{
    private int nextId = 1;
    private int id;

    public Badge()
    {
        id = nextId;
        nextId++;
    }

    public int getId()
    {
        return id;
    }
}

public class BadgeBug
{
    public static void main(String[] args)
    {
        Badge first = new Badge();
        Badge second = new Badge();
        Badge third = new Badge();
        System.out.println(first.getId());
        System.out.println(second.getId());
        System.out.println(third.getId());
    }
}

    private static int nextId = 1;

class Quiz
{
    public static final int BONUS = 5;
    private static int quizzesGraded = 0;
    private int score;

    public Quiz(int startingScore)
    {
        score = startingScore;
        quizzesGraded++;
    }

    public int getScore()
    {
        return score;
    }

    public static void addBonus(Quiz target)
    {
        target.score += BONUS;
    }

    public static int getQuizzesGraded()
    {
        return quizzesGraded;
    }
}

public class ScoreBoost
{
    public static void main(String[] args)
    {
        Quiz first = new Quiz(80);
        Quiz second = new Quiz(91);
        Quiz same = first;
        Quiz.addBonus(first);
        Quiz.addBonus(same);
        Quiz.addBonus(second);
        System.out.println(first.getScore());
        System.out.println(second.getScore());
        System.out.println(Quiz.getQuizzesGraded());
    }
}

90
96
2

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

• I can declare a class variable with static and explain why all objects share one copy. Reread
• I can use a public class variable from another class with the class name and a dot. Reread
• I can explain what final does and write a class constant. Reread
• I can write a class method that reads or changes class variables and calls other class methods. Reread
• I can explain why a class method needs an object parameter to use instance data, and fix code that breaks this rule. Reread