Q 17 - Overriding Static Method & Static Variables

[AmjustGettingStarted]

🚫 Can Static Variables or Methods Be Overridden?

[HARSHITH-MV]

Great question! Let’s unravel the mystery of static variables and methods in Java—stylishly. 🌟

---

🚫 Can Static Variables or Methods Be Overridden?

❌ Static Variables — Cannot Be Overridden

• Why? Static variables belong to the class, not to instances. Since overriding is a behavior related to instances and inheritance, static variables don’t play that game.
• Think of them as global settings shared across all objects of the class.

❌ Static Methods — Cannot Be Truly Overridden

• Static methods are bound during compile-time, not runtime—so they follow method hiding, not overriding.
• If a subclass defines a static method with the same signature as one in its superclass:
  • The superclass method is hidden, not overridden.
  • The method that gets called depends on the reference type, not the object type.

---

✨ Quick Code Illustration

class Parent {
    static void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    static void greet() {
        System.out.println("Hello from Child");
    }
}

public class Demo {
    public static void main(String[] args) {
        Parent obj = new Child();
        obj.greet(); // Prints: Hello from Parent
    }
}

🔎 Even though obj is a Child object, the reference type is Parent, so Parent's greet() is called.

---

🌈 Summary Table

Feature	Static Variable	Static Method
Belongs To	Class	Class
Inheritance Use	Shared, not overridden	Hidden, not overridden
Compile Time?	✅ Yes	✅ Yes
Polymorphic?	❌ No	❌ No

---

Static members are powerful in their own right, but they don’t mix with polymorphism the same way instance members do🤓

[HARSHITH-MV]

🏛️ Static Variable Inheritance in Java

🔹 Core Concept

• A static variable belongs to the class, not to an object.
• When a child class inherits from a parent, it can access and even modify the static variable.
• But since it's tied to the parent class, changing it from the child still affects the same shared value.

---

✏️ Code Illustration

class Parent {
    static String familyName = "Roy";
}
class Child extends Parent {

void changeName() {

familyName = "Singh"; // changing the static variable

}

}
public class Demo {

public static void main(String[] args) {

System.out.println("Before Change: " + Parent.familyName);
    Child child = new Child();
    child.changeName();

    System.out.println("After Change: " + Parent.familyName);
}

}

🧪 Output:

Before Change: Roy
After Change: Singh

---

📌 Key Takeaways

Feature	Explanation
Belongs to	Class (not to any instance)
Inherited by child?	✅ Yes
Access mechanism	Can be accessed using parent or child class name
Modification effect	Change is reflected across all references

---

💡 Pro Tip: Even though you can access and modify static variables from a child class, it’s clearer and better practice to do so using the class name directly, like Parent.familyName, to emphasize its class-level nature.

[AmjustGettingStarted]

• Static variables cannot be overridden because they belong to the class, not an individual instance.
• However, they can be inherited by child classes and their value can be changed.
• When modified from any class (parent or child), the new value affects all classes that share it because it's a shared class-level property, not instance-specific.

Example:

class Parent {
    static int count = 10;
}

class Child extends Parent {
    void updateCount() {
        count = 99;  // changing static variable
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("Before change: " + Parent.count);  // 10
        Child c = new Child();
        c.updateCount();
        System.out.println("After change: " + Parent.count);   // 99
    }
}

Key Points:

• ✅ Inherited: Yes
• ❌ Overridden: No
• ✏️ Mutable: Yes (but shared across all references)

[AmjustGettingStarted]

🤓 Static Variables are Hidden when Inherited?

---

Yes, that's exactly the terminology used in Java: when a child class declares a static variable with the same name as the parent’s, the original variable is hidden, not overridden. 🕵️‍♂️

Let’s clarify the difference with a direct example:

class Parent {
    static String message = "Hello from Parent";
}

class Child extends Parent {
    static String message = "Hello from Child"; // hides Parent.message
}

public class Demo {
    public static void main(String[] args) {
        System.out.println(Parent.message); // Prints: Hello from Parent
        System.out.println(Child.message);  // Prints: Hello from Child

        Parent obj = new Child();
        System.out.println(obj.message);    // Still prints: Hello from Parent
    }
}

🔍 What’s happening here?

• Parent.message and Child.message are two separate static variables that just happen to share the same name.
• Because static variables are bound at compile-time, the reference type (Parent) determines which variable is accessed—not the actual object type.
• This behavior is called variable hiding, not overriding.

🔄 Summary

Feature	Instance Variable	Static Variable
Inheritance	✅ Supports polymorphism	✅ Accessible but not polymorphic
Behavior	Can be overridden	Hidden (not overridden)
Binding Time	Runtime	Compile-time

If you'd like to see how this affects memory layout or combine it with methods for a full contrast, we can go even deeper. 🧠📊 Ready when you are!