Static variables in Java - Time & Space Complexity

Time Complexity: Static variables

O(n)

Understanding Time Complexity

Let's explore how using static variables affects the time it takes for a program to run.

We want to see if static variables change how the program's work grows as input grows.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

public class Counter {
    static int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}
    

This code defines a static variable count shared by all instances, incremented by the increment method.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Incrementing the static variable count each time increment() is called.
• How many times: Once per call to increment(), no loops inside the method.

How Execution Grows With Input

Each call to increment() does one simple step: add one to count.

Input Size (n)	Approx. Operations
10	10 increments
100	100 increments
1000	1000 increments

Pattern observation: The work grows directly with how many times you call increment(). No extra loops or nested work.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows in a straight line with the number of increments done.

Common Mistake

[X] Wrong: "Static variables make the program faster or slower because they are shared."

[OK] Correct: Static variables just share data across instances but do not change how many steps the program takes to run.

Interview Connect

Understanding static variables helps you explain how data is shared in programs and how that affects performance in simple ways.

Self-Check

"What if the increment() method had a loop that ran n times inside it? How would the time complexity change?"

Practice

1. What is a key characteristic of a static variable in Java?

easy

A. It belongs to the class and is shared by all instances.

B. It is unique to each object created from the class.

C. It can only be accessed inside instance methods.

D. It is automatically deleted when an object is destroyed.

Solution

1. Step 1: Understand static variable ownership

   A static variable belongs to the class itself, not to any individual object.

2. Step 2: Recognize sharing behavior

   Because it belongs to the class, all objects share the same static variable value.

3. Final Answer:

   It belongs to the class and is shared by all instances. -> Option A

4. Quick Check:

   Static variable = shared by all objects [OK]

Hint: Static means shared by class, not per object [OK]

Common Mistakes:

• Thinking static variables are unique per object
• Confusing static with instance variables
• Assuming static variables are deleted with objects

2. Which of the following is the correct way to declare a static variable in Java?

easy

A. static int count;

B. int static count;

C. int count static;

D. count static int;

Solution

1. Step 1: Recall Java syntax for static variables

   The keyword static comes before the type when declaring a static variable.

2. Step 2: Check each option

   Only static int count; follows the correct syntax.

3. Final Answer:

   static int count; -> Option A

4. Quick Check:

   static keyword before type = correct syntax [OK]

Hint: Put 'static' before the type when declaring [OK]

Common Mistakes:

• Placing static after the variable name
• Mixing order of keywords
• Using invalid syntax order

3. What will be the output of the following Java code?

class Test {
    static int count = 0;
    Test() {
        count++;
    }
    public static void main(String[] args) {
        new Test();
        new Test();
        System.out.println(Test.count);
    }
}

medium

A. Compilation error

B. 1

C. 0

D. 2

Solution

1. Step 1: Understand static variable incrementation

   Each time a new Test object is created, the constructor increments count by 1.

2. Step 2: Count the number of objects created

   Two objects are created, so count becomes 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Two objects increment count twice = 2 [OK]

Hint: Static count increments with each new object [OK]

Common Mistakes:

• Assuming count resets for each object
• Confusing instance and static variables
• Expecting compilation error due to static usage

4. Identify the error in the following code snippet:

class Counter {
    static int count;
    void increment() {
        count++;
    }
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        System.out.println(count);
    }
}

medium

A. Cannot access static variable from instance method.

B. No error; code runs and prints 1.

C. Cannot access static variable directly in static method without class name.

D. Static variable count is not initialized.

Solution

1. Step 1: Check static variable initialization

   Static int variables default to 0 if not explicitly initialized.

2. Step 2: Verify method calls and access

   The instance method increment() correctly increments the static variable. The static method main accesses count directly, which is allowed.

3. Final Answer:

   No error; code runs and prints 1. -> Option B

4. Quick Check:

   Static variable accessible and increments correctly [OK]

Hint: Static vars default to 0; accessible in static main [OK]

Common Mistakes:

• Thinking static vars must be explicitly initialized
• Assuming static vars can't be accessed without class name inside same class
• Confusing instance and static method access rules

5. Consider this Java class:

class Employee {
    static int employeeCount = 0;
    String name;
    Employee(String name) {
        this.name = name;
        employeeCount++;
    }
    static void printCount() {
        System.out.println("Total employees: " + employeeCount);
    }
}

public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee("Alice");
        Employee e2 = new Employee("Bob");
        e1.printCount();
        Employee.printCount();
    }
}

What will be the output when running Main?

hard

A. Total employees: 1
Total employees: 2

B. Total employees: 2
Total employees: 1

C. Total employees: 2
Total employees: 2

D. Compilation error due to calling static method on instance

Solution

1. Step 1: Count employees created

   Two Employee objects are created, so employeeCount becomes 2.

2. Step 2: Understand static method calls

   Calling printCount() on instance e1 or class Employee both print the same static variable value.

3. Final Answer:

   Total employees: 2 Total employees: 2 -> Option C

4. Quick Check:

   Static method prints shared count = 2 [OK]

Hint: Static method prints shared count; instance call allowed [OK]

Common Mistakes:

• Thinking static method can't be called on instance
• Assuming employeeCount resets per object
• Confusing output order or values