Kann ich statische Methoden in Java überschreiben und überladen?

Ich würde gerne wissen:

1. Warum können statische Methoden in Java nicht überschrieben werden?
2. Können statische Methoden in Java überladen werden?

Statische Methoden können nicht im genauen Sinne des Wortes überschrieben werden, sie können jedoch übergeordnete statische Methoden ausblenden

In der Praxis bedeutet dies, dass der Compiler entscheidet, welche Methode zur Kompilierungszeit und nicht zur Laufzeit ausgeführt werden soll, wie dies bei überschriebenen Instanzmethoden der Fall ist.

Ein gutes Beispiel finden Sie hier .

In dieser Java-Dokumentation wird der Unterschied zwischen dem Überschreiben von Instanzmethoden und dem Ausblenden von (statischen) Klassenmethoden erläutert .

Überschreiben: Überschreiben in Java bedeutet einfach, dass die bestimmte Methode basierend auf dem Laufzeittyp des Objekts und nicht auf dem Kompilierungszeittyp des Objekts aufgerufen wird (was bei statischen Methoden zum Überschreiben der Fall ist).

Ausblenden: Übergeordnete Klassenmethoden, die statisch sind, sind nicht Teil einer untergeordneten Klasse (obwohl auf sie zugegriffen werden kann), sodass es keine Frage gibt, sie zu überschreiben. Selbst wenn Sie einer Unterklasse eine andere statische Methode hinzufügen, die mit der in der übergeordneten Klasse identisch ist, ist diese statische Methode der Unterklasse eindeutig und unterscheidet sich von der statischen Methode in der übergeordneten Klasse.

Statische Methoden können nicht überschrieben werden, da nichts zu überschreiben ist, da es sich um zwei verschiedene Methoden handelt. Zum Beispiel

static class Class1 {
    public static int Method1(){
          return 0;
    }
}
static class Class2 extends Class1 {
    public static int Method1(){
          return 1;
    }

}
public static class Main {
    public static void main(String[] args){
          //Must explicitly chose Method1 from Class1 or Class2
          Class1.Method1();
          Class2.Method1();
    }
}

Und ja, statische Methoden können wie jede andere Methode überladen werden.

Statische Methoden können nicht überschrieben werden, da sie zur Laufzeit nicht auf der Objektinstanz ausgelöst werden. Der Compiler entscheidet, welche Methode aufgerufen wird.

Aus diesem Grund erhalten Sie beim Schreiben eine Compiler-Warnung

 MyClass myObject = new MyClass();
 myObject.myStaticMethod();
 // should be written as
 MyClass.myStaticMethod()
 // because it is not dispatched on myObject
 myObject = new MySubClass();
 myObject.myStaticMethod(); 
 // still calls the static method in MyClass, NOT in MySubClass

Statische Methoden können überladen werden (dh Sie können für mehrere Methoden denselben Methodennamen verwenden, sofern sie unterschiedliche Parametertypen haben).

 Integer.parseInt("10");
 Integer.parseInt("AA", 16);

Übergeordnete Klassenmethoden, die statisch sind, sind nicht Teil einer untergeordneten Klasse (obwohl auf sie zugegriffen werden kann), sodass es keine Frage gibt, sie zu überschreiben. Selbst wenn Sie einer Unterklasse eine andere statische Methode hinzufügen, die mit der in der übergeordneten Klasse identisch ist, ist diese statische Methode der Unterklasse eindeutig und unterscheidet sich von der statischen Methode in der übergeordneten Klasse.

Statische Methoden können nicht überschrieben werden, da sie nicht Teil des Objektstatus sind. Sie gehören vielmehr zur Klasse (dh sie sind Klassenmethoden). Es ist in Ordnung, statische (und endgültige) Methoden zu überladen.

Wenn ich die Methode unter Verwendung des Unterklassennamens MysubClass aufrufe, zeigt die Unterklassenmethode an, was bedeutet, dass die statische Methode überschrieben werden kann oder nicht

class MyClass {
    static void myStaticMethod() {
        System.out.println("Im in sta1");
    }
}

class MySubClass extends MyClass {

    static void  myStaticMethod() {
        System.out.println("Im in sta123");
    }
}

public class My {
    public static void main(String arg[]) {

        MyClass myObject = new MyClass();
        myObject.myStaticMethod();
        // should be written as
        MyClass.myStaticMethod();
        // calling from subclass name
        MySubClass.myStaticMethod();
        myObject = new MySubClass();
        myObject.myStaticMethod(); 
        // still calls the static method in MyClass, NOT in MySubClass
    }
}

Statische Methoden sind Methoden, deren einzelne Kopie von allen Objekten der Klasse gemeinsam genutzt wird. Die statische Methode gehört eher zur Klasse als zu den Objekten. Da statische Methoden nicht von den Objekten abhängen, muss der Java Compiler nicht bis zur Objekterstellung warten. Um die statische Methode aufzurufen, verwenden wir eine Syntax wie ClassName.method ().

Im Falle einer Methodenüberladung sollten sich Methoden in derselben Klasse befinden, um sie zu überladen. Auch wenn sie als statisch deklariert sind, können sie wie folgt überladen werden:

   Class Sample
    {
         static int calculate(int a,int b,int c)
           {
                int res = a+b+c;
                return res;
           }
           static int calculate(int a,int b)
           {
                int res = a*b;
                return res;
           }
}
class Test
{
   public static void main(String []args)
   {
     int res = Sample.calculate(10,20,30);
   }
}

Beim Überschreiben von Methoden fungieren die Methode in der Superklasse und die Methode in der Unterklasse jedoch als unterschiedliche Methoden. Die Superklasse hat eine eigene Kopie und die Unterklasse hat eine eigene Kopie, sodass sie nicht unter das Überschreiben von Methoden fällt.

Überladen wird auch als statische Bindung bezeichnet. Sobald das Wort statisch verwendet wird, bedeutet dies, dass eine statische Methode keinen Laufzeitpolymorphismus anzeigen kann .

Wir können eine statische Methode nicht überschreiben, aber das Vorhandensein verschiedener Implementierungen derselben statischen Methode in einer Superklasse und ihrer Unterklasse ist gültig. Es ist nur so, dass die abgeleitete Klasse die Implementierungen der Basisklasse verbirgt.

Bei statischen Methoden hängt der Methodenaufruf von der Art der Referenz ab und nicht davon, auf welches Objekt verwiesen wird. Das heißt, die statische Methode gehört nur zu einer Klasse und nicht zu deren Instanzen. Daher wird der Methodenaufruf zur Kompilierungszeit selbst entschieden.

Während bei Methodenüberladung statische Methoden überladen werden können, wenn sie unterschiedliche Anzahlen oder Arten von Parametern haben. Wenn zwei Methoden denselben Namen und dieselbe Parameterliste haben, können sie nicht nur mit dem Schlüsselwort 'static' unterschiedlich definiert werden.

Nein, statische Methoden können nicht überschrieben werden, da sie Teil einer Klasse und nicht eines Objekts sind. Man kann aber statische Methoden überladen.

staticMethoden sind classLevel-Methoden.

Das Versteckkonzept wird für staticMethoden verwendet.

Siehe: http://www.coderanch.com/how-to/java/OverridingVsHiding

class SuperType {

    public static void  classMethod(){
        System.out.println("Super type class method");
    }
    public void instancemethod(){
        System.out.println("Super Type instance method");
    }
}


public class SubType extends SuperType{


    public static void classMethod(){
        System.out.println("Sub type class method");
    }
    public void instancemethod(){
        System.out.println("Sub Type instance method");
    }
    public static void main(String args[]){
        SubType s=new SubType();
        SuperType su=s;
        SuperType.classMethod();// Prints.....Super type class method
        su.classMethod();   //Prints.....Super type class method
        SubType.classMethod(); //Prints.....Sub type class method 
    }
}

Dieses Beispiel für das Überschreiben statischer Methoden

Hinweis: Wenn wir eine statische Methode mit Objektreferenz aufrufen, wird die statische Methode des Referenztyps (Klasse) aufgerufen, nicht die statische Methode der Objektklasse.

Die statische Methode gehört nur zur Klasse.

Der eigentliche Zweck der Verwendung der statischen Methode besteht darin, auf die Methode einer Klasse zuzugreifen, ohne eine Instanz dafür zu erstellen. Es macht keinen Sinn, wenn wir diese Methode überschreiben, da auf sie über classname.method () zugegriffen wird.

Nein, Sie können eine statische Methode nicht überschreiben. Die Statik wird gegen die Klasse aufgelöst, nicht gegen die Instanz.

public class Parent { 
    public static String getCName() { 
        return "I am the parent"; 
    } 
} 

public class Child extends Parent { 
    public static String getCName() { 
        return "I am the child"; 
    } 
} 

Jede Klasse hat eine statische Methode getCName (). Wenn Sie den Klassennamen aufrufen, verhält er sich wie erwartet und jeder gibt den erwarteten Wert zurück.

@Test 
public void testGetCNameOnClass() { 
    assertThat(Parent.getCName(), is("I am the parent")); 
    assertThat(Child.getCName(), is("I am the child")); 
} 

Keine Überraschungen bei diesem Unit-Test. Dies wird jedoch nicht außer Kraft gesetzt. Dies deklariert etwas, das eine Namenskollision aufweist.

Wenn wir versuchen, die Statik von einer Instanz der Klasse aus zu erreichen (keine gute Praxis), zeigt dies wirklich:

private Parent cp = new Child(); 
`enter code here`
assertThat(cp.getCName(), is("I am the parent")); 

Obwohl cp ein untergeordnetes Element ist, wird die statische Aufladung durch den deklarierten Typ Parent anstelle des tatsächlichen Objekttyps aufgelöst. Bei nicht statischen Methoden wird dies korrekt behoben, da eine nicht statische Methode eine übergeordnete Methode überschreiben kann.

Sie können eine statische Methode überladen, eine statische Methode jedoch nicht überschreiben. Eigentlich können Sie eine statische Methode in Unterklassen umschreiben, dies wird jedoch nicht als Überschreibung bezeichnet, da die Überschreibung mit Polymorphismus und dynamischer Bindung zusammenhängen sollte. Die statische Methode gehört zur Klasse und hat also nichts mit diesen Konzepten zu tun. Das Umschreiben der statischen Methode ähnelt eher einem Schatten.

Ich entwerfe einen Code zum Überschreiben statischer Methoden. Ich denke, er kann leicht überschrieben werden. Bitte machen Sie mir klar, dass statische Elemente nicht überschrieben werden können. Hier ist mein Code.

class Class1 {
    public static int Method1(){
          System.out.println("true");
          return 0;
    }
}
class Class2 extends Class1 {
    public static int Method1(){
   System.out.println("false");
          return 1;
    }

}
public class Mai {
    public static void main(String[] args){
           Class2 c=new Class2();
          //Must explicitly chose Method1 from Class1 or Class2
          //Class1.Method1();
          c.Method1();
    }
}

Es ist eigentlich ziemlich einfach zu verstehen - Alles, was als statisch markiert ist, gehört nur zur Klasse. Beispielsweise kann die statische Methode nicht in die Unterklasse vererbt werden, da sie zu der Klasse gehört, in der sie deklariert wurden. Verweisen Sie auf das statische Schlüsselwort.

Die beste Antwort auf diese Frage ist:

http://www.geeksforgeeks.org/can-we-overload-or-override-static-methods-in-java/

Da jede statische Methode Teil der Klasse nicht der Instanz ist, ist es nicht möglich, die statische Methode zu überschreiben

Von Warum erlaubt Java das Überschreiben statischer Methoden nicht?

Das Überschreiben hängt von einer Instanz einer Klasse ab. Der Punkt des Polymorphismus besteht darin, dass Sie eine Klasse unterklassifizieren können und die Objekte, die diese Unterklassen implementieren, unterschiedliche Verhaltensweisen für dieselben Methoden aufweisen, die in der Oberklasse definiert (und in den Unterklassen überschrieben) sind. Eine statische Methode ist keiner Instanz einer Klasse zugeordnet, sodass das Konzept nicht anwendbar ist.

Es gab zwei Überlegungen, die das Design von Java beeinflussten. Eines war ein Problem mit der Leistung: Smalltalk wurde vielfach kritisiert, weil es zu langsam sei (Garbage Collection und polymorphe Aufrufe gehören dazu), und Javas Entwickler waren entschlossen, dies zu vermeiden. Ein weiterer Grund war die Entscheidung, dass die Zielgruppe für Java C ++ - Entwickler waren. Wenn statische Methoden so funktionieren, wie sie funktionieren, sind sie für C ++ - Programmierer vertraut und sehr schnell, da Sie nicht bis zur Laufzeit warten müssen, um herauszufinden, welche Methode aufgerufen werden soll.

Auf keinen Fall können wir statische Methoden in Java überschreiben. Weil JVM die korrekte überschriebene Methode basierend auf dem Objekt zur Laufzeit mithilfe der dynamischen Bindung in Java auflöst.

Die statische Methode in Java ist jedoch eher der Klasse als dem Objekt zugeordnet und wird während der Kompilierungszeit aufgelöst und verbunden.