Why static is needed in Java - See It in Action

Why static is needed

📖 Scenario: Imagine you are creating a simple program to count how many objects of a class have been created. You want to keep track of this count without needing to ask each object individually.

🎯 Goal: You will build a Java program that uses a static variable to count the total number of objects created from a class. This shows why static is needed to share data across all objects.

📋 What You'll Learn

Create a class called Counter with a static variable count initialized to 0

Add a constructor in Counter that increases count by 1 each time an object is created

Create three objects of Counter in the main method

Print the value of Counter.count to show how many objects were created

💡 Why This Matters

🌍 Real World

Counting objects or tracking shared data is common in programs like games, inventory systems, or user sessions.

💼 Career

Understanding <code>static</code> is important for writing efficient Java code and managing shared resources in software development.

1

Create the Counter class with a static count variable

Create a class called Counter with a static int count variable initialized to 0.

Java

public class Counter {
    // Your code here
}

Hint

The static keyword means the variable belongs to the class, not to any one object.

2

Add a constructor that increases count

Add a constructor to the Counter class that increases the count variable by 1 each time a new object is created.

Java

public class Counter {
    static int count = 0;

    // Your code here
}

Hint

The constructor runs automatically when you create a new object.

3

Create three Counter objects in main

In the main method, create three objects of the Counter class named c1, c2, and c3.

Java

public class Counter {
    static int count = 0;

    public Counter() {
        count++;
    }

    public static void main(String[] args) {
        // Your code here
    }
}

Hint

Creating objects calls the constructor and increases the count.

4

Print the total count of objects created

Add a System.out.println statement in the main method to print the value of Counter.count.

Java

public class Counter {
    static int count = 0;

    public Counter() {
        count++;
    }

    public static void main(String[] args) {
        Counter c1 = new Counter();
        Counter c2 = new Counter();
        Counter c3 = new Counter();
        // Your code here
    }
}

Hint

The static variable count keeps track of all objects created.

Practice

1. Why do we use the static keyword in Java?

easy

A. To allow inheritance from other classes

B. To make a member belong to the class rather than any object

C. To make a method private

D. To create a new object automatically

Solution

1. Step 1: Understand what static means

   The static keyword means the member belongs to the class itself, not to any individual object.

2. Step 2: Compare with other options

   Creating objects, privacy, and inheritance are unrelated to static.

3. Final Answer:

   To make a member belong to the class rather than any object -> Option B

4. Quick Check:

   Static means class-level member = D [OK]

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

Common Mistakes:

• Thinking static creates objects
• Confusing static with private access
• Assuming static controls inheritance

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

easy

A. public static void myMethod() {}

B. static void public myMethod() {}

C. public void static myMethod() {}

D. void static public myMethod() {}

Solution

1. Step 1: Recall Java method declaration order

   In Java, the correct order is access modifier, then static, then return type, then method name.

2. Step 2: Check each option

   public static void myMethod() {} follows this order: public static void myMethod(). Others have incorrect order.

3. Final Answer:

   public static void myMethod() {} -> Option A

4. Quick Check:

   Access modifier + static + return type = A [OK]

Hint: Remember: access modifier before static before return type [OK]

Common Mistakes:

• Placing static after method name
• Omitting static keyword
• Wrong order of keywords

3. What will be the output of this code?

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

medium

A. Compilation error

B. 1

C. 0

D. 2

Solution

1. Step 1: Understand static variable behavior

   The static variable count is shared by all objects of the class. Each time a new object is created, the constructor increments count.

2. Step 2: Count object creations

   Two objects are created with new Test() twice, so count becomes 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Static count increments twice = 2 [OK]

Hint: Static variables keep shared count across all objects [OK]

Common Mistakes:

• Thinking count resets for each object
• Confusing static with instance variables
• Expecting compilation error due to static

4. Identify the error in this code:

class Demo {
    static void show() {
        System.out.println("Hello");
    }
    public static void main(String[] args) {
        show();
        Demo d = new Demo();
        d.show();
    }
}

medium

A. Cannot call static method using object reference

B. Missing return type in show method

C. No error, code runs fine

D. Static method cannot access System.out

Solution

1. Step 1: Check static method calls

   Static methods can be called using class name or object reference. Both show() and d.show() are valid.

2. Step 2: Verify method declaration and usage

   The method show() has correct return type void and uses System.out.println correctly.

3. Final Answer:

   No error, code runs fine -> Option C

4. Quick Check:

   Static methods callable via object or class = B [OK]

Hint: Static methods can be called via object or class name [OK]

Common Mistakes:

• Thinking static methods can't be called on objects
• Assuming missing return type error
• Believing static can't use System.out

5. You want to count how many times a method is called across all objects of a class. Which approach is best?

hard

A. Use a static variable incremented inside the method

B. Use an instance variable incremented inside the method

C. Create a new object each time and count in constructor

D. Use a local variable inside the method to count calls

Solution

1. Step 1: Understand counting across all objects

   To count calls across all objects, the counter must be shared by all instances, so it must be static.

2. Step 2: Evaluate other options

   Instance variables count per object, local variables reset each call, and creating new objects won't track method calls properly.

3. Final Answer:

   Use a static variable incremented inside the method -> Option A

4. Quick Check:

   Shared counter needs static variable = C [OK]

Hint: Use static variable to share count across all objects [OK]

Common Mistakes:

• Using instance variable which counts per object only
• Using local variable which resets every call
• Counting in constructor unrelated to method calls