The static keyword

One interest rate, a thousand accounts

What does static mean?

Words you'll meet in this lesson

Instance vs static at a glance

Four places you can write static

The fourth, static nested classes, gets its own lesson (10.5). And static imports let you use static members without the class name:

import static java.lang.Math.max;
import static java.lang.Math.PI;

public class Main {
    public static void main(String[] args) {
        System.out.println(max(12, 30));        // instead of Math.max
        System.out.println(PI * 2 * 2);         // instead of Math.PI
    }
}

Static blocks run once, at first use

class Config {
    static int gstRate;
    static {
        System.out.println("Config loading...");
        gstRate = 18;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("main starts");
        System.out.println(Config.gstRate);
        System.out.println(Config.gstRate);
    }
}

“Config loading...” prints only once, and only when Config is first used, not when the program starts. That's class initialisation, which you'll see in detail in Lesson 8.4.

Static and instance members working together

1. Declare which data is shared

   class Account {
       static double rate = 7.0;   // one for all accounts
       static int count = 0;       // how many accounts exist
       double balance;             // one per account

   When the class is initialised, the JVM creates storage for rate and count once, with the class. No object exists yet.

2. Update the shared counter in the constructor

       Account(double opening) {
           balance = opening;   // this object's field
           count++;             // the class's field
       }

   Each new Account(…) creates a fresh balance inside the new object, but all of them increment the same count.

3. Instance methods can read static fields

       double yearlyInterest() {
           return balance * rate / 100;   // own balance, shared rate
       }

   Inside an instance method there is a current object (this), and the class is always reachable, so both kinds of member are available.

4. Static methods have no current object

       static void setRate(double r) {
           rate = r;           // fine: static field
           // balance = 0;     // error: which account's balance?
       }

   A static method runs without this. Writing balance there gives non-static variable balance cannot be referenced from a static context. To use an object's fields, pass the object in as a parameter.

5. Call static members through the class name

   Account.setRate(6.5);
   System.out.println(Account.count + " accounts at " + Account.rate + "%");

   You can write a1.rate, but it hides the fact that the value is shared. IDEs warn about it; use the class name.

Three accounts, one shared rate

Left: the code and what it prints. Right: the objects on the heap, each with its own balance, and the single copy of the static fields kept with the class.

static in real projects

Every Java codebase uses static members, mostly for constants and helper methods. Mutable static state is used more carefully.

Watch it with an example: token numbers at a clinic

Every patient gets a Token object with its own number, but one static counter at the reception hands out the numbers, so no two patients get the same one.

Examples are simplified. Large applications avoid mutable static fields for business data, because frameworks may run several copies of the code and tests need fresh state.

Riya's bank with a shared rate

class Account {
    static double rate = 7.0;
    static int count = 0;
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;
        this.balance = balance;
        count++;
    }

    double yearlyInterest() {
        return balance * rate / 100;
    }

    static void setRate(double newRate) {
        rate = newRate;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Riya", 5000);
        Account b = new Account("Kabir", 12000);
        System.out.println(Account.count + " accounts at " + Account.rate + "%");
        System.out.println(a.owner + ": " + a.yearlyInterest() + ", " + b.owner + ": " + b.yearlyInterest());
        Account.setRate(6.5);
        System.out.println(a.owner + ": " + a.yearlyInterest() + ", " + b.owner + ": " + b.yearlyInterest());
    }
}

• static double rateOne copy for the class. Every account reads the same value.
• count++Runs in every constructor call, always on the same shared field.
• static void setRateCalled on the class: Account.setRate(6.5). It has no this.
• Account.countRead through the class name, which makes it obvious the value is shared.

A static counter on the real JVM

This tracer also shows static fields at the top of the heap list. Watch one Token.next serve every object.

Worked examples: real problems, solved and traced in memory

Three common, correct uses of static: a utility method, a constant with a counter, and a shared setting. In each trace, static fields appear at the top of the heap list.

price 1200 at 18%, price 450 at 5%

GST on cover: Rs 216
GST on book: Rs 22

passengers Asha, Ravi, Meena

MP-1001 Asha
MP-1002 Ravi
Bookings made: 2

minimum 1000, then 3000; balances 2500 and 800

a pays fee: false, b pays fee: true
a pays fee: true, b pays fee: true

Check yourself

Quick revision

Interview and viva questions

Practice problems

Decide what should be static and what shouldn't, and practise static methods, blocks and counters. The last three are real business tasks.

Riya, Kabir, Asha

Students: 3

class Student {
    static int count = 0;
    String name;

    Student(String name) {
        this.name = name;
        count++;
    }
}

public class Main {
    public static void main(String[] args) {
        new Student("Riya");
        new Student("Kabir");
        new Student("Asha");
        System.out.println("Students: " + Student.count);
    }
}

isEven(7), square(12)

false
144

class MathUtil {
    static boolean isEven(int n) {
        return n % 2 == 0;
    }

    static int square(int n) {
        return n * n;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(MathUtil.isEven(7));
        System.out.println(MathUtil.square(12));
    }
}

shop = "Chai Point"

Chai Point
Welcome to Chai Point

public class Main {
    String shop = "Chai Point";

    void welcome() {
        System.out.println("Welcome to " + shop);
    }

    public static void main(String[] args) {
        Main m = new Main();
        System.out.println(m.shop);
        m.welcome();
    }
}

codes: MH, KA, TN, DL; look up index 2

Looking up...
State table ready
TN
MH

class States {
    static String[] codes = new String[4];

    static {
        codes[0] = "MH";
        codes[1] = "KA";
        codes[2] = "TN";
        codes[3] = "DL";
        System.out.println("State table ready");
    }

    static String at(int i) {
        return codes[i];
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Looking up...");
        System.out.println(States.at(2));
        System.out.println(States.at(0));
    }
}

video A played 3 times, video B played 2 times

Java in 10 min: 3
UPI explained: 2
Platform total: 5

class Video {
    static int totalViews = 0;
    String title;
    int views = 0;

    Video(String title) {
        this.title = title;
    }

    void play() {
        views++;
        totalViews++;
    }
}

public class Main {
    public static void main(String[] args) {
        Video a = new Video("Java in 10 min");
        Video b = new Video("UPI explained");
        a.play(); a.play(); a.play();
        b.play(); b.play();
        System.out.println(a.title + ": " + a.views);
        System.out.println(b.title + ": " + b.views);
        System.out.println("Platform total: " + Video.totalViews);
    }
}

rate 83.0 then 83.5; convert Rs 8300 and Rs 16700

$100.0
$201.2
$99.4

class Fx {
    static double inrPerUsd = 83.0;

    static double toUsd(double inr) {
        return Math.round(inr / inrPerUsd * 100) / 100.0;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("$" + Fx.toUsd(8300));
        System.out.println("$" + Fx.toUsd(16700));
        Fx.inrPerUsd = 83.5;
        System.out.println("$" + Fx.toUsd(8300));
    }
}

booking requests: Asha, Ravi, Meena, Kabir

Asha: seat 1
Ravi: seat 2
Meena: seat 3
Kabir: sold out
Booked 3 of 3

class Ticket {
    static final int CAPACITY = 3;
    static int booked = 0;

    static boolean book(String name) {
        if (booked >= CAPACITY) {
            System.out.println(name + ": sold out");
            return false;
        }
        booked++;
        System.out.println(name + ": seat " + booked);
        return true;
    }
}

public class Main {
    public static void main(String[] args) {
        String[] people = {"Asha", "Ravi", "Meena", "Kabir"};
        for (String p : people) {
            Ticket.book(p);
        }
        System.out.println("Booked " + Ticket.booked + " of " + Ticket.CAPACITY);
    }
}

three invoices

FY25-0001
FY25-0002
FY25-0003

class Invoice {
    static final String FY = "FY25";
    static int last = 0;
    String no;

    Invoice() {
        last++;
        no = FY + "-" + String.format("%04d", last);
    }
}

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 3; i++) {
            System.out.println(new Invoice().no);
        }
    }
}

Real-world scenario questions (asked in company interviews)

Interviewers use static to see whether you understand shared state. Decide your answer, then open the model answer.