Why static is needed in Java - Quick Recap

Recall & Review

beginner

What does the static keyword mean in Java?

It means the member (variable or method) belongs to the class itself, not to any specific object of the class.

beginner

Why do we use static methods in Java?

Because static methods can be called without creating an object, making them useful for utility or helper functions.

beginner

How does a static variable differ from an instance variable?

A static variable is shared by all objects of the class, while an instance variable is unique to each object.

intermediate

Can a static method access instance variables directly? Why or why not?

No, because static methods belong to the class, and instance variables belong to objects. Without an object, instance variables don't exist.

beginner

Give a real-life example of when static is useful.

Think of a calculator app: the add method can be static because it doesn’t need to remember any data, it just adds numbers given to it.

What does the static keyword do in Java?

A Makes a member belong to the class itself

B Makes a member private

C Makes a member final

D Makes a member abstract

Static means the member belongs to the class, not to any object.

Which of these can be called without creating an object?

A Instance method

B Static method

C Instance variable

D Constructor

Static methods belong to the class and can be called directly.

Static variables are shared by:

A All objects of the class

B Only one object

C No objects

D Only subclasses

Static variables are common to all objects of the class.

Can a static method access instance variables directly?

A Yes, always

B Only if the instance variable is final

C No, because instance variables belong to objects

D Only if the static method is private

Static methods don’t have access to instance variables without an object.

Why might you make a method static?

A To save memory by sharing it across objects

B To make it private

C To make it abstract

D To allow calling it without creating an object

Static methods can be called directly on the class without objects.

Explain why static variables are useful in Java.

Think about data that should be the same for every object.

Describe a situation where you would use a static method instead of an instance method.

When the method doesn’t rely on object-specific information.

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