This post extends our previous discussions on the static keyword by focusing on the concepts of method overloading and method overriding in the context of static methods. We’ll also explore how the this and super keywords behave (or don’t) in a static context.

If you’re new to static keyword, it may be helpful to first go through Static Variables and Static Methods.

Since this post touches upon the behavior of this and super in a static context, you may also want to go through This Keyword and Super Keyword.

Key Topics in This Post:

1. Overloading of Static Methods

2. Why Static Methods Cannot Be Overridden

3. Using this and super Keywords in Static Context

4. Examples Demonstrating the Key Concepts

1. Overloading Static Methods

In Java, overloading allows methods with the same name to exist with different parameter lists. Static methods can be overloaded just like instance methods. However, keep in mind that overloading occurs at compile time.

Code Example:

package keywords.static_keyword;

public class StaticVariables {

    static int idStatic = 1;

    public StaticVariables(String name) {
        this.id = ++idStatic;
        this.name = name;
    }

    int id;
    String name;

    static void displayText() {
        System.out.println("DisplayText called. ID: " + idStatic);
    }

    // Overloaded static method with a parameter
    static void displayText(String name) {
        System.out.println("Overloaded DisplayText called. Name: " + name);
    }

    public static void main(String[] args) {
        StaticVariables.displayText();
        StaticVariables.displayText("Static Overload Example");
    }
}

Explanation:

• Method Overloading: The displayText method is overloaded with two versions—one without parameters and one with a String parameter.

• This is legal since Java can differentiate the two methods based on their parameter lists during compile time.

2. Why Static Methods Cannot Be Overridden

Java doesn’t allow overriding of static methods. Since static methods are bound to the class rather than to an object instance, they don’t participate in runtime polymorphism, which is the basis of method overriding.

However, static variables are inherited and can be accessed or modified by child classes.

Code Example:

package keywords.static_keyword;

public class CannotOverrideStaticMethod extends StaticVariables {

    public CannotOverrideStaticMethod(String name) {
        super(name);
    }

    // Attempting to override the static method 
    // This will cause a compile-time error
    /*
    @Override
    static void displayText() {
        System.out.println("Overridden DisplayText");
    }
    */

    @Override
    void display() {
        // Static variables are inherited from the parent class
        idStatic = 90;  // Access and modify the parent's static variable
        System.out.println("ID: " + idStatic + ", Name: " + name);
        super.display();  // Call the parent class's non-static method
    }

    // Correct way to use static methods from the parent class
    static void displayText() {
        StaticVariables.displayText(); // Call the parent class static method
    }

    public static void main(String[] args) {
        displayText();  // Calls the static method defined in this class
    }
}

Explanation:

• No Overriding: The commented-out @Override method demonstrates an attempt to override a static method, which results in a compile-time error because overriding is only applicable to instance methods.

• Static Variable Inheritance: Even though static methods can’t be overridden, static variables are inherited and can be accessed or modified in child classes.

• Calling Static Methods: Static methods must be called using the class name or directly if they are within the same class.

3. Use of this and super Keywords in Static Context

• this Keyword: Refers to the current instance of the class. Since static methods don’t operate on any instance, using this in a static context will cause a compile-time error.

Example:

static void displayText() {
    // Cannot use 'this' in a static context
    this.display();  // --> Compile-time error
}

• super Keyword: Similarly, the super keyword refers to the parent class's instance. Since static methods belong to the class and not an instance, super is also invalid in a static context.

Example:

static void displayText() {
    // Cannot use 'super' in a static context
    super.displayText();  // --> Compile-time error
    StaticVariables.displayText();  // Correct usage
}

Additional Explanation:

• Concept 1: Overriding enables runtime polymorphism, which relies on instances. Since static methods do not associate with instances, they cannot be overridden. However, static variables are inherited and can be accessed or modified in child classes, as shown in the example.

• Concept 2: Both this and super refer to an instance—this refers to the current object's members, while super refers to the parent object's members. Since static methods operate independently of any instance, neither this nor super can be used in static methods or static blocks.

4. Summary of Key Concepts

• Static Methods Can Be Overloaded: You can define multiple static methods with the same name but different parameter lists. This is resolved during compile time.

• Static Methods Cannot Be Overridden: Since static methods belong to the class rather than an instance, they don’t support runtime polymorphism.

• Static Variables Are Inherited: Static variables from the parent class can be accessed and modified in child classes.

• No this or super in Static Context: As static methods do not operate on instances, the this and super keywords cannot be used.

Conclusion

In this post, we covered the nuances of overloading and overriding static methods, discussed the constraints of using this and super in static contexts, and explained how static variables behave across inheritance. These concepts are essential for understanding how static members differ from instance members in Java.

Related Posts

• Java Fundamentals

• Array Interview Essentials

• Java Memory Essentials

• Java OOPs Essentials

• Collections Framework Essentials

Happy Coding!