Posted in Java

Can we overload and override static methods in java?

   September 5, 2024

In Java, static methods can be overloaded but not overridden. Here’s a detailed explanation based on the search results:

Overloading Static Methods

  • Definition: Overloading occurs when two or more methods in the same class (or subclass) have the same name but different parameters (different type or number of parameters).
  • Example: You can have multiple static methods with the same name as long as their parameter lists differ.
class Example {
    static void display() {
        System.out.println("No parameters");
    }

    static void display(int a) {
        System.out.println("One parameter: " + a);
    }

    static void display(int a, String b) {
        System.out.println("Two parameters: " + a + ", " + b);
    }
}

public class Test {
    public static void main(String[] args) {
        Example.display();
        Example.display(10);
        Example.display(10, "Hello");
    }
}

In this example, the display method is overloaded with different parameter lists.

Overriding Static Methods

  • Definition: Overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. However, this concept does not apply to static methods.
  • Reason: Static methods belong to the class itself rather than to instances of the class. When a static method in a subclass has the same name and parameter list as a static method in the superclass, it does not override the superclass method; instead, it hides it.
  • Example:
class Parent {
    static void show() {
        System.out.println("Static method in Parent");
    }
}

class Child extends Parent {
    static void show() {
        System.out.println("Static method in Child");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent childAsParent = new Child();

        parent.show(); // Calls Parent's show method
        childAsParent.show(); // Calls Parent's show method, not Child's
    }
}

In this example, even though Child has a static method show, calling show on a reference of type Parent will invoke the Parent‘s show method, demonstrating that static methods are not overridden.

When you call childAsParent.show(), it also calls the static method from the Parent class because childAsParent is of type Parent, and method resolution for static methods is based on the reference type, not the object type.

Summary

  • Overloading: Static methods can be overloaded by changing the parameter list (type or number of parameters) within the same class or subclass.
  • Overriding: Static methods cannot be overridden because they are associated with the class itself, and the method resolution happens at compile time based on the reference type, not the object type.

Thus, in Java, you can overload static methods but cannot override them.

In Hindi

स्टेटिक मेथड्स का ओवरलोडिंग

  • परिभाषा: ओवरलोडिंग तब होती है जब एक ही क्लास (या सबक्लास) में दो या दो से अधिक मेथड्स का नाम समान होता है लेकिन उनके पैरामीटर्स अलग होते हैं (पैरामीटर्स का प्रकार या संख्या भिन्न होती है)।
  • उदाहरण: आप एक ही नाम के कई स्टेटिक मेथड्स रख सकते हैं, बशर्ते कि उनके पैरामीटर की सूचियाँ भिन्न हों।
class Parent {
    static void show() {
        System.out.println("Static method in Parent");
    }
}

class Child extends Parent {
    static void show() {
        System.out.println("Static method in Child");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent childAsParent = new Child();

        parent.show(); // Calls Parent's show method
        childAsParent.show(); // Calls Parent's show method, not Child's
    }
}

इस उदाहरण में, display मेथड को विभिन्न पैरामीटर सूचियों के साथ ओवरलोड किया गया है।

स्टेटिक मेथड्स का ओवरराइडिंग

  • परिभाषा: ओवरराइडिंग तब होती है जब एक सबक्लास एक विशेष कार्यान्वयन प्रदान करता है जो पहले से ही उसके सुपरक्लास में परिभाषित एक मेथड है। हालांकि, यह अवधारणा स्टेटिक मेथड्स पर लागू नहीं होती है।
  • कारण: स्टेटिक मेथड्स क्लास के साथ जुड़े होते हैं, न कि क्लास के उदाहरणों के साथ। जब एक सबक्लास में एक स्टेटिक मेथड उसी नाम और पैरामीटर सूची के साथ होता है जो सुपरक्लास में होता है, तो यह सुपरक्लास के मेथड को ओवरराइड नहीं करता; बल्कि इसे छुपा देता है।
  • उदाहरण:
class Parent {
    static void show() {
        System.out.println("पैरेंट में स्टेटिक मेथड");
    }
}

class Child extends Parent {
    static void show() {
        System.out.println("चाइल्ड में स्टेटिक मेथड");
    }
}

public class Test {
    public static void main(String[] args) {
        Parent parent = new Parent();
        Parent childAsParent = new Child();

        parent.show(); // पैरेंट का show मेथड कॉल करता है
        childAsParent.show(); // पैरेंट का show मेथड कॉल करता है, चाइल्ड का नहीं
    }
}

इस उदाहरण में, भले ही Child में एक स्टेटिक मेथड show है, Parent के प्रकार के संदर्भ पर show कॉल करने पर Parent का show मेथड ही कॉल होगा, जो दिखाता है कि स्टेटिक मेथड्स का ओवरराइड नहीं होता है।

सारांश

  • ओवरलोडिंग: स्टेटिक मेथड्स को ओवरलोड किया जा सकता है, यदि पैरामीटर सूची (प्रकार या संख्या) को बदल दिया जाए, एक ही क्लास या सबक्लास के भीतर।
  • ओवरराइडिंग: स्टेटिक मेथड्स का ओवरराइड नहीं किया जा सकता क्योंकि वे क्लास के साथ जुड़े होते हैं, और मेथड का समाधान संदर्भ प्रकार के आधार पर होता है, न कि ऑब्जेक्ट प्रकार के आधार पर।

इस प्रकार, जावा में, आप स्टेटिक मेथड्स को ओवरलोड कर सकते हैं लेकिन उन्हें ओवरराइड नहीं कर सकते।

Author: learnwithdey