static: belonging to the class

Written Explanation

Instance versus static

So far, balance has been an instance field: ten accounts, ten balances. The Java tutorial calls a static field a class variable. Each object has its own id, for instance, while a single shared field keeps count of how many objects exist.

A static field: a shared counter

public class Account {
    static int count = 0;       // one copy, shared by every Account

    String owner;
    String number;
    double balance;

    Account(String owner, String number, double balance) {
        this.owner = owner;
        this.number = number;
        this.balance = balance;
        count++;                // runs for each new account
    }
}

Every time any constructor runs, it increments the same count. Outside the class, you read it through the class name:

System.out.println(Account.count);   // 0, before any account exists

Note the 0 before any object exists. A static field exists as soon as the class is loaded, with no object needed. Java also lets you write ana.count, but the tutorial advises against it, because it hides that count is not about ana. Always use Account.count.

A static final constant

When a value is shared and must never change, combine static with final:

static final double MIN_DEPOSIT = 0.01;

final means the variable cannot be reassigned after it gets its value, and the compiler enforces it:

Bad2.java:3: error: cannot assign a value to static final variable MIN_DEPOSIT
        Account.MIN_DEPOSIT = 5;
               ^

By convention, constant names use upper-case letters with underscores between words. Constants are static because one copy for the whole class is enough: it makes no sense for every account to store its own MIN_DEPOSIT. You already know a constant from the standard library, Math.PI.

A static method

A static method is called on the class and does not need an object:

static int getCount() {
    return count;
}

static boolean isValidNumber(String number) {
    return number != null && number.startsWith("A-");
}

Account.getCount();
Account.isValidNumber("A-9");     // true

You have used this form all along: Math.max(3, 5) is a static method of Math, and your own main is static.

The big restriction

Static members are shared, so a static method has no current object. It has no this, and it cannot read instance fields or call instance methods directly. The tutorial summarizes the rules:

• Instance methods can use instance members and static members.
• Static methods can use static members only. To use an instance member, they need an object reference.

Here is what the compiler says when you break the rule:

public class Bad {
    double balance = 5;
    static double show() {
        return balance;          // which object's balance?
    }
}

Bad.java:4: error: non-static variable balance cannot be referenced from a static context
        return balance;
               ^

The message is the question "which object's balance?" in compiler words. If the method really needs one object's data, it should not be static. The error will also appear if you call an instance method such as deposit from main without an object, which is why you need new first. The usual (wrong) cure for this error is to add static to the field or method, and then the problem moves elsewhere. Think about what the member belongs to.

Rule of thumb: when is it static?

Ask: is it about one particular object, or about the class as a whole?

• Depends on one object's state (balance, deposit, describe): instance.
• Same for all objects, or needs no object (count, MIN_DEPOSIT, isValidNumber): static.
• When in doubt, start with instance. A class where everything is static is just a bag of global variables and functions, and it throws away what objects offer: separate state per object.