Java Notes

static Keyword in Java

Complete guide to the static keyword in Java — static variables, methods, blocks, inner classes, imports, and understanding class-level vs instance-level members.

The static keyword marks a member as belonging to the class rather than to any specific object. A static member exists once, is shared by all instances, and can be accessed without creating an object.

Think of it this way: instance members are like personal items each student carries. Static members are like the classroom whiteboard — shared by everyone, only one copy exists.

static Variables (Class Variables)

A static variable is shared across ALL objects of the class:

Example

public class Student { // Instance variables - each student has their own copy private String name; private int rollNumber; // Static variable - shared by ALL students private static int totalStudents = 0; private static String schoolName = "Springfield High"; public Student(String name) { this.name = name; totalStudents++; // Increments for every new student this.rollNumber = totalStudents; } public void displayInfo() { System.out.println(rollNumber + ". " + name + " - " + schoolName); } public static int getTotalStudents() { return totalStudents; } } public class Main { public static void main(String[] args) { Student s1 = new Student("Alice"); Student s2 = new Student("Bob"); Student s3 = new Student("Charlie"); s1.displayInfo(); s2.displayInfo(); s3.displayInfo(); System.out.println("Total students: " + Student.getTotalStudents()); } }

Output

1. Alice - Springfield High
2. Bob - Springfield High
3. Charlie - Springfield High
Total students: 3

Memory Layout

Student.totalStudents = 3		s1: name="Alice"
Student.schoolName = "..."		rollNumber=1

static vs Instance Variables

Feature	Static Variable	Instance Variable
Belongs to	Class	Object
Memory	Method Area (one copy)	Heap (one per object)
Access	`ClassName.var` or `obj.var`	`obj.var` only
Lifetime	Program start to end	Object creation to GC
Default value	Yes (0, null, false)	Yes (0, null, false)
Use case	Counters, constants, shared config	Object-specific data

static Methods (Class Methods)

Static methods belong to the class and can be called without an object:

Example

public class MathUtils { // Static utility methods - no object needed public static int max(int a, int b) { return a > b ? a : b; } public static int min(int a, int b) { return a < b ? a : b; } public static double average(int... numbers) { int sum = 0; for (int n : numbers) sum += n; return (double) sum / numbers.length; } public static boolean isPrime(int n) { if (n < 2) return false; for (int i = 2; i <= Math.sqrt(n); i++) { if (n % i == 0) return false; } return true; } public static int factorial(int n) { if (n < 0) throw new IllegalArgumentException("Negative input"); int result = 1; for (int i = 2; i <= n; i++) result *= i; return result; } } public class Main { public static void main(String[] args) { // Called on the CLASS, not on an object System.out.println("Max: " + MathUtils.max(10, 20)); System.out.println("Average: " + MathUtils.average(85, 92, 78, 95, 88)); System.out.println("7 is prime? " + MathUtils.isPrime(7)); System.out.println("5! = " + MathUtils.factorial(5)); } }

Output

Max: 20
Average: 87.6
7 is prime? true
5! = 120

Restrictions in Static Methods

Static methods cannot access instance members directly:

java example

public class Demo {
    private int instanceVar = 10;
    private static int staticVar = 20;

    public static void staticMethod() {
        System.out.println(staticVar);     // ✅ Static can access static
        // System.out.println(instanceVar); // ❌ Cannot access instance variable
        // instanceMethod();                // ❌ Cannot call instance method
        // System.out.println(this);        // ❌ No 'this' in static context
    }

    public void instanceMethod() {
        System.out.println(instanceVar);   // ✅ Instance can access instance
        System.out.println(staticVar);     // ✅ Instance can access static
        staticMethod();                    // ✅ Instance can call static
    }
}

Why? Static methods can be called without an object. Without an object, there's no instance state to access.

static Block (Static Initializer)

A static block runs once when the class is first loaded into memory:

java example

public class DatabaseConfig {
    private static String url;
    private static String username;
    private static String password;
    private static Map<String, String> settings;

    // Static block - runs once when class loads
    static {
        System.out.println("Loading database configuration...");
        settings = new HashMap<>();
        try {
            // Simulate loading from config file
            url = "jdbc:mysql://localhost:3306/myapp";
            username = "admin";
            password = "secret123";
            settings.put("pool_size", "10");
            settings.put("timeout", "30000");
            System.out.println("Configuration loaded successfully");
        } catch (Exception e) {
            System.err.println("Failed to load config: " + e.getMessage());
            throw new RuntimeException("Cannot start without config", e);
        }
    }

    // Multiple static blocks execute in order
    static {
        System.out.println("Additional initialization...");
        settings.put("retry_count", "3");
    }

    public static String getUrl() { return url; }
    public static String getSetting(String key) { return settings.get(key); }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Accessing DatabaseConfig...");
        System.out.println("URL: " + DatabaseConfig.getUrl());
        System.out.println("Pool: " + DatabaseConfig.getSetting("pool_size"));
    }
}

Output

Loading database configuration...
Configuration loaded successfully
Additional initialization...
Accessing DatabaseConfig...
URL: jdbc:mysql://localhost:3306/myapp
Pool: 10

Execution Order

java example

public class ExecutionOrder {
    // Static variable with initializer
    private static int x = initX();

    // Static block
    static {
        System.out.println("2. Static block");
    }

    // Instance initializer
    {
        System.out.println("4. Instance initializer");
    }

    // Constructor
    public ExecutionOrder() {
        System.out.println("5. Constructor");
    }

    private static int initX() {
        System.out.println("1. Static variable initializer");
        return 10;
    }

    public static void main(String[] args) {
        System.out.println("3. Main method");
        new ExecutionOrder();
        new ExecutionOrder();
    }
}

Output

1. Static variable initializer
2. Static block
3. Main method
4. Instance initializer
5. Constructor
4. Instance initializer
5. Constructor

Note: Static initialization happens ONCE. Instance initialization happens for EACH object.

static Constants

The most common use of static is with final to create constants:

java example

public class Constants {
    public static final double PI = 3.14159265358979;
    public static final int MAX_USERS = 1000;
    public static final String APP_NAME = "MyApplication";
    public static final String VERSION = "2.1.0";

    // Private constructor - cannot instantiate utility class
    private Constants() {
        throw new AssertionError("Cannot instantiate Constants");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        double circumference = 2 * Constants.PI * 5;
        System.out.println("App: " + Constants.APP_NAME + " v" + Constants.VERSION);
        System.out.println("Circumference: " + circumference);
    }
}

Output

App: MyApplication v2.1.0
Circumference: 31.4159265358979

static Inner Class

A static inner class doesn't have access to the outer class's instance members:

Example

public class LinkedList { private Node head; private int size; // Static inner class - doesn't need reference to LinkedList instance private static class Node { int data; Node next; Node(int data) { this.data = data; } } public void add(int data) { Node newNode = new Node(data); newNode.next = head; head = newNode; size++; } public void display() { Node current = head; while (current != null) { System.out.print(current.data + " -> "); current = current.next; } System.out.println("null"); } } public class Main { public static void main(String[] args) { LinkedList list = new LinkedList(); list.add(30); list.add(20); list.add(10); list.display(); } }

Output

10 -> 20 -> 30 -> null

Factory Method Pattern with static

Example

public class Logger { private String name; private String level; private static Map<String, Logger> instances = new HashMap<>(); // Private constructor private Logger(String name) { this.name = name; this.level = "INFO"; } // Static factory method public static Logger getLogger(String name) { return instances.computeIfAbsent(name, Logger::new); } public void setLevel(String level) { this.level = level; } public void info(String message) { log("INFO", message); } public void error(String message) { log("ERROR", message); } private void log(String level, String message) { System.out.println("[" + level + "] " + name + ": " + message); } } public class Main { public static void main(String[] args) { Logger appLogger = Logger.getLogger("Application"); Logger dbLogger = Logger.getLogger("Database"); appLogger.info("Application started"); dbLogger.info("Connected to database"); dbLogger.error("Query timeout"); // Same reference returned for same name Logger appLogger2 = Logger.getLogger("Application"); System.out.println("Same instance? " + (appLogger == appLogger2)); } }

Output

[INFO] Application: Application started
[INFO] Database: Connected to database
[ERROR] Database: Query timeout
Same instance? true

static Import

Import static members directly to avoid qualifying with class name:

java example

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;
import static java.lang.System.out;

public class StaticImportDemo {
    public static void main(String[] args) {
        // Without static import: Math.sqrt(), System.out.println()
        // With static import:
        double hypotenuse = sqrt(pow(3, 2) + pow(4, 2));
        out.println("Hypotenuse: " + hypotenuse);
        out.println("Circle area (r=5): " + PI * pow(5, 2));
    }
}

Output

Hypotenuse: 5.0
Circle area (r=5): 78.53981633974483

Use sparingly — overusing static import makes code less readable.

Real-World Example: Counter/ID Generator

Example

public class OrderIdGenerator { private static long lastId = 0; private static final String PREFIX = "ORD"; private static final Object lock = new Object(); public static String generateId() { synchronized (lock) { lastId++; return PREFIX + "-" + String.format("%06d", lastId); } } // Reset for testing static void reset() { synchronized (lock) { lastId = 0; } } } public class Order { private String orderId; private String customerName; private double total; public Order(String customerName, double total) { this.orderId = OrderIdGenerator.generateId(); this.customerName = customerName; this.total = total; } @Override public String toString() { return orderId + " | " + customerName + " | $" + total; } } public class Main { public static void main(String[] args) { Order o1 = new Order("Alice", 150.00); Order o2 = new Order("Bob", 89.99); Order o3 = new Order("Charlie", 245.50); System.out.println(o1); System.out.println(o2); System.out.println(o3); } }

Output

ORD-000001 | Alice | $150.0
ORD-000002 | Bob | $89.99
ORD-000003 | Charlie | $245.5

Common Mistakes

Accessing instance members from static methods:

``java private String name; public static void printName() { System.out.println(name); // ❌ Cannot access instance var from static } ``

Using this in static context:

``java public static void method() { this.doSomething(); // ❌ No 'this' in static } ``

Overriding static methods (you can't!):

``java class Parent { public static void greet() { System.out.println("Parent"); } } class Child extends Parent { public static void greet() { System.out.println("Child"); } // This is METHOD HIDING, not overriding! No polymorphism. } Parent p = new Child(); p.greet(); // Prints "Parent" — resolved at compile time! ``

Mutable static state in multi-threaded code:

``java private static int counter; // ❌ Race condition in multi-threaded code // Fix: use AtomicInteger or synchronization ``

Overusing static — making everything static:

``java // ❌ Procedural code disguised as OOP public class UserService { public static void createUser(String name) { } public static User getUser(int id) { } public static void deleteUser(int id) { } } // ✅ Use instance methods — allows polymorphism, testing, etc. ``

Best Practices

Use static for utility methods that don't depend on state (Math.abs())
Use static final for constants
Use static factory methods instead of constructors for controlled creation
Avoid mutable static variables — they're global state
Make utility classes non-instantiable (private constructor)
Be careful with static in multi-threaded environments
Don't use static just to avoid creating objects — that defeats OOP

Interview Questions

Q1: Can we override static methods? No. Static methods are resolved at compile time (early binding). A child class can define the same method (method hiding), but it's not polymorphic.

Q2: Why is main() method static? JVM needs to call main() without creating an object of the class. If main() were non-static, JVM would need to instantiate the class first — creating a chicken-and-egg problem.

Q3: Can a static method access instance variables? Not directly. It needs an object reference: new MyClass().instanceVar. Static methods have no this.

Q4: What is the difference between static and instance initialization blocks? Static blocks run once when the class loads. Instance blocks run every time an object is created, before the constructor.

Q5: Can a class be declared static? Only inner classes can be static. Top-level classes cannot be declared static.

Q6: What is method hiding? When a subclass defines a static method with the same signature as the parent. Unlike overriding, the method called depends on the reference type, not the object type.

Q7: When should you use static methods? When the method doesn't use any instance state — utility methods, factory methods, and operations that logically belong to the class rather than any particular instance.

Q8: What is the difference between static method and instance method? Static methods belong to the class, can be called without an object, cannot access this or instance variables, and are resolved at compile time. Instance methods belong to objects, need an object to call, can access both static and instance members, and support polymorphism (dynamic dispatch).

Q9: Can a static block throw an exception? Yes, but only unchecked exceptions. If a checked exception occurs, it must be caught within the block. If a static block throws an exception, the class fails to load and ExceptionInInitializerError is thrown. The class cannot be used after this.

Q10: What is the difference between static import and regular import? Regular import imports classes: import java.util.Math; then use Math.sqrt(). Static import imports static members directly: import static java.lang.Math.sqrt; then use sqrt() without the class name. Overusing static imports reduces code readability.

Q11: Can we serialize static variables? No. Serialization saves object state (instance variables). Static variables belong to the class, not the object, so they're not serialized. After deserialization, static variables will have whatever value is current in the JVM, not the value at serialization time.

Q12: Why should utility classes have a private constructor? Utility classes (like Math, Arrays) contain only static methods and shouldn't be instantiated. A private constructor prevents new MathUtils() which would be meaningless. Also add throw new AssertionError() inside to prevent reflection-based instantiation.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for static Keyword in Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, oops, static, keyword

Continue learning this concept

OOPssuper Keyword in JavaComplete guide to the super keyword in Java — accessing parent class members, calling parent constructors, resolving method hiding, and understanding the super chain in inheritance hierarchies.OOPsthis Keyword in JavaComplete guide to the this keyword in Java — referencing current object, resolving ambiguity, constructor chaining, passing current object, and returning current instance for fluent APIs.OOPsAbstract Class in JavaComplete guide to abstract classes in Java — abstract methods, partial implementation, when to use abstract classes, template method pattern, and abstract class vs interface comparison.OOPsAbstraction in JavaComplete guide to abstraction in Java — hiding complexity, abstract classes and interfaces, abstraction layers, real-world design, and achieving loose coupling through abstraction.OOPsAnonymous Class in JavaComplete guide to anonymous classes in Java — creating inline implementations, event handlers, comparators, and understanding when lambdas replaced anonymous classes.OOPsClass and Object in JavaDeep dive into Java classes and objects — class anatomy, object creation, memory allocation, instance vs class members, and how objects work under the hood in the JVM.

PreviousPolymorphism in Java Nextsuper Keyword in Java

Java Notes

static Keyword in Java

Complete guide to the static keyword in Java — static variables, methods, blocks, inner classes, imports, and understanding class-level vs instance-level members.

Think of it this way: instance members are like personal items each student carries. Static members are like the classroom whiteboard — shared by everyone, only one copy exists.

static Variables (Class Variables)

A static variable is shared across ALL objects of the class:

Example

Output

1. Alice - Springfield High
2. Bob - Springfield High
3. Charlie - Springfield High
Total students: 3

Memory Layout

Student.totalStudents = 3		s1: name="Alice"
Student.schoolName = "..."		rollNumber=1

static vs Instance Variables

Feature	Static Variable	Instance Variable
Belongs to	Class	Object
Memory	Method Area (one copy)	Heap (one per object)
Access	`ClassName.var` or `obj.var`	`obj.var` only
Lifetime	Program start to end	Object creation to GC
Default value	Yes (0, null, false)	Yes (0, null, false)
Use case	Counters, constants, shared config	Object-specific data

static Methods (Class Methods)

Static methods belong to the class and can be called without an object:

Example

Output

Max: 20
Average: 87.6
7 is prime? true
5! = 120

Restrictions in Static Methods

Static methods cannot access instance members directly:

java example

public class Demo {
    private int instanceVar = 10;
    private static int staticVar = 20;

    public static void staticMethod() {
        System.out.println(staticVar);     // ✅ Static can access static
        // System.out.println(instanceVar); // ❌ Cannot access instance variable
        // instanceMethod();                // ❌ Cannot call instance method
        // System.out.println(this);        // ❌ No 'this' in static context
    }

    public void instanceMethod() {
        System.out.println(instanceVar);   // ✅ Instance can access instance
        System.out.println(staticVar);     // ✅ Instance can access static
        staticMethod();                    // ✅ Instance can call static
    }
}

Why? Static methods can be called without an object. Without an object, there's no instance state to access.

static Block (Static Initializer)

A static block runs once when the class is first loaded into memory:

java example

public class DatabaseConfig {
    private static String url;
    private static String username;
    private static String password;
    private static Map<String, String> settings;

    // Static block - runs once when class loads
    static {
        System.out.println("Loading database configuration...");
        settings = new HashMap<>();
        try {
            // Simulate loading from config file
            url = "jdbc:mysql://localhost:3306/myapp";
            username = "admin";
            password = "secret123";
            settings.put("pool_size", "10");
            settings.put("timeout", "30000");
            System.out.println("Configuration loaded successfully");
        } catch (Exception e) {
            System.err.println("Failed to load config: " + e.getMessage());
            throw new RuntimeException("Cannot start without config", e);
        }
    }

    // Multiple static blocks execute in order
    static {
        System.out.println("Additional initialization...");
        settings.put("retry_count", "3");
    }

    public static String getUrl() { return url; }
    public static String getSetting(String key) { return settings.get(key); }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Accessing DatabaseConfig...");
        System.out.println("URL: " + DatabaseConfig.getUrl());
        System.out.println("Pool: " + DatabaseConfig.getSetting("pool_size"));
    }
}

Output

Loading database configuration...
Configuration loaded successfully
Additional initialization...
Accessing DatabaseConfig...
URL: jdbc:mysql://localhost:3306/myapp
Pool: 10

Execution Order

java example

public class ExecutionOrder {
    // Static variable with initializer
    private static int x = initX();

    // Static block
    static {
        System.out.println("2. Static block");
    }

    // Instance initializer
    {
        System.out.println("4. Instance initializer");
    }

    // Constructor
    public ExecutionOrder() {
        System.out.println("5. Constructor");
    }

    private static int initX() {
        System.out.println("1. Static variable initializer");
        return 10;
    }

    public static void main(String[] args) {
        System.out.println("3. Main method");
        new ExecutionOrder();
        new ExecutionOrder();
    }
}

Output

1. Static variable initializer
2. Static block
3. Main method
4. Instance initializer
5. Constructor
4. Instance initializer
5. Constructor

Note: Static initialization happens ONCE. Instance initialization happens for EACH object.

static Constants

The most common use of static is with final to create constants:

java example

public class Constants {
    public static final double PI = 3.14159265358979;
    public static final int MAX_USERS = 1000;
    public static final String APP_NAME = "MyApplication";
    public static final String VERSION = "2.1.0";

    // Private constructor - cannot instantiate utility class
    private Constants() {
        throw new AssertionError("Cannot instantiate Constants");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        double circumference = 2 * Constants.PI * 5;
        System.out.println("App: " + Constants.APP_NAME + " v" + Constants.VERSION);
        System.out.println("Circumference: " + circumference);
    }
}

Output

App: MyApplication v2.1.0
Circumference: 31.4159265358979

static Inner Class

A static inner class doesn't have access to the outer class's instance members:

Example

Output

10 -> 20 -> 30 -> null

Factory Method Pattern with static

Example

Output

[INFO] Application: Application started
[INFO] Database: Connected to database
[ERROR] Database: Query timeout
Same instance? true

static Import

Import static members directly to avoid qualifying with class name:

java example

import static java.lang.Math.PI;
import static java.lang.Math.sqrt;
import static java.lang.Math.pow;
import static java.lang.System.out;

public class StaticImportDemo {
    public static void main(String[] args) {
        // Without static import: Math.sqrt(), System.out.println()
        // With static import:
        double hypotenuse = sqrt(pow(3, 2) + pow(4, 2));
        out.println("Hypotenuse: " + hypotenuse);
        out.println("Circle area (r=5): " + PI * pow(5, 2));
    }
}

Output

Hypotenuse: 5.0
Circle area (r=5): 78.53981633974483

Use sparingly — overusing static import makes code less readable.

Real-World Example: Counter/ID Generator

Example

Output

ORD-000001 | Alice | $150.0
ORD-000002 | Bob | $89.99
ORD-000003 | Charlie | $245.5

Common Mistakes

Accessing instance members from static methods:

``java private String name; public static void printName() { System.out.println(name); // ❌ Cannot access instance var from static } ``

Using this in static context:

``java public static void method() { this.doSomething(); // ❌ No 'this' in static } ``

Overriding static methods (you can't!):

Mutable static state in multi-threaded code:

``java private static int counter; // ❌ Race condition in multi-threaded code // Fix: use AtomicInteger or synchronization ``

Overusing static — making everything static:

Best Practices

Use static for utility methods that don't depend on state (Math.abs())
Use static final for constants
Use static factory methods instead of constructors for controlled creation
Avoid mutable static variables — they're global state
Make utility classes non-instantiable (private constructor)
Be careful with static in multi-threaded environments
Don't use static just to avoid creating objects — that defeats OOP

Interview Questions

Q1: Can we override static methods? No. Static methods are resolved at compile time (early binding). A child class can define the same method (method hiding), but it's not polymorphic.

Q3: Can a static method access instance variables? Not directly. It needs an object reference: new MyClass().instanceVar. Static methods have no this.

Q5: Can a class be declared static? Only inner classes can be static. Top-level classes cannot be declared static.

Q6: What is method hiding? When a subclass defines a static method with the same signature as the parent. Unlike overriding, the method called depends on the reference type, not the object type.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for static Keyword in Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, oops, static, keyword

Continue learning this concept

PreviousPolymorphism in Java Nextsuper Keyword in Java