Static methods in Java - Step-by-Step Execution

Concept Flow - Static methods

Call Class.staticMethod()

↓

Enter static method

↓

Execute method body

↓

Return result or void

↓

Back to caller

Static methods belong to the class, not instances. You call them using the class name, they run their code, then return control.

Execution Sample

Java

class MathUtils {
    static int square(int x) {
        return x * x;
    }
}

int result = MathUtils.square(4);

This code defines a static method to square a number and calls it using the class name.

Execution Table

Step	Action	Input	Operation	Output/Return
1	Call MathUtils.square(4)	4	Enter static method with x=4	No output yet
2	Calculate x * x	4	4 * 4	16
3	Return result	16	Return 16 to caller	16 assigned to result
4	End	-	-	Method execution complete

💡 Method returns after computing and returning the square of input.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
x	-	4	4	4	4
result	-	-	-	16	16

Key Moments - 3 Insights

Why do we call the method using the class name instead of an object?

Static methods belong to the class itself, not to any object instance, so you call them with ClassName.methodName(), as shown in step 1 of the execution_table.

Can static methods access instance variables?

No, static methods cannot access instance variables because they do not belong to any object. This example only uses the parameter x, which is local to the method.

What happens if we try to use 'this' inside a static method?

'this' refers to the current object, but static methods have no object context, so using 'this' inside a static method causes a compile error.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'x' when the method starts executing?

A undefined

B 16

C 4

D 0

💡 Hint

Check Step 1 and variable_tracker for 'x' value after Step 1.

At which step does the method return the result to the caller?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Return result' action in the execution_table.

If we change the call to MathUtils.square(5), what will be the output at Step 2?

A 25

B 10

C 5

D 20

💡 Hint

Step 2 shows the calculation x * x, so with x=5, it will be 5*5.

Concept Snapshot

Static methods belong to the class, not instances.
Call them using ClassName.methodName().
They cannot access instance variables or 'this'.
Useful for utility functions.
Return values like normal methods.

Full Transcript

Static methods in Java are methods that belong to the class itself rather than any object instance. You call them using the class name, like MathUtils.square(4). When called, the method runs its code using the input parameters, then returns a result or void. In the example, the static method square takes an integer x, calculates x times x, and returns the result. Variables inside static methods are local to the method. Static methods cannot use 'this' or access instance variables because they have no object context. This makes static methods great for utility functions that don't need object data. The execution table shows the method call, calculation, return, and completion steps clearly. The variable tracker shows how 'x' and 'result' change during execution.

Practice

1. Which statement about static methods in Java is true?

easy

A. Static methods belong to the class and can be called without creating an object.

B. Static methods can only be called on objects of the class.

C. Static methods can access instance variables directly.

D. Static methods must always return void.

Solution

1. Step 1: Understand what static means

   Static methods belong to the class itself, not to any object instance.

2. Step 2: Check method calling rules

   Static methods can be called using the class name without creating an object.

3. Final Answer:

   Static methods belong to the class and can be called without creating an object. -> Option A

4. Quick Check:

   Static method = class method call [OK]

Hint: Static methods use class name, no object needed [OK]

Common Mistakes:

• Thinking static methods need an object to call
• Assuming static methods access instance variables
• Believing static methods must return void

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

easy

A. public void static myMethod() {}

B. static void public myMethod() {}

C. public static void 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 keyword, then return type, then method name.

2. Step 2: Match the correct syntax

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

3. Final Answer:

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

4. Quick Check:

   Access + static + return type = correct order [OK]

Hint: Remember: access modifier before static keyword [OK]

Common Mistakes:

• Placing static after return type
• Omitting access modifier
• Mixing order of keywords

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

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

medium

A. 2

B. 1

C. Compilation error

D. 0

Solution

1. Step 1: Understand static variable and method behavior

   The static variable count starts at 0 and is shared by all calls.

2. Step 2: Trace method calls

   Each call to increment() increases count by 1. Called twice, count becomes 2.

3. Final Answer:

   2 -> Option A

4. Quick Check:

   Two increments = count 2 [OK]

Hint: Static variables keep value across static method calls [OK]

Common Mistakes:

• Thinking count resets each call
• Confusing static and instance variables
• Expecting compilation error due to static usage

4. Identify the error in the following code snippet:

public class Example {
    int x = 5;
    static void printX() {
        System.out.println(x);
    }
}

medium

A. Missing return type for printX method.

B. Cannot use instance variable x inside static method printX.

C. Static methods cannot have print statements.

D. Class Example must be declared static.

Solution

1. Step 1: Check static method access rules

   Static methods cannot access instance variables directly because they belong to the class, not an object.

2. Step 2: Identify the error in code

   Method printX() tries to print instance variable x without an object, causing an error.

3. Final Answer:

   Cannot use instance variable x inside static method printX. -> Option B

4. Quick Check:

   Static method can't access instance variables directly [OK]

Hint: Static methods can't use instance variables directly [OK]

Common Mistakes:

• Assuming static methods can access instance variables
• Thinking static methods need return type fix
• Believing classes must be static

5. You want to create a utility class MathUtils with a static method square(int n) that returns the square of a number. Which implementation is correct?

hard

A. public class MathUtils { public int square(int n) { return n * n; } }

B. public class MathUtils { static void square(int n) { return n * n; } }

C. public static class MathUtils { public int square(int n) { return n * n; } }

D. public class MathUtils { public static int square(int n) { return n * n; } }

Solution

1. Step 1: Identify static method requirements

   The method should be static to call without creating an object.

2. Step 2: Check method signature and return type

   Method must return int and be declared static with proper access modifier.

3. Step 3: Validate options

   public class MathUtils { public static int square(int n) { return n * n; } } correctly declares a public static method returning int.

4. Final Answer:

   public class MathUtils { public static int square(int n) { return n * n; } } -> Option D

5. Quick Check:

   Static method with return type and public access [OK]

Hint: Utility methods should be static with correct return type [OK]

Common Mistakes:

• Omitting static keyword
• Using void return type when returning value
• Declaring class static incorrectly