Perché il metodo statico del padre è nascosto nel sottomanifesto Java?

Quando ci sono due classi, una che estende un'altra classe, se queste due classi hanno metodi identici, inclusi i parametri e il tipo di ritorno (ad esempio, esempio), il metodo nella sottoclasse sovrascriverà il metodo nella superclasse.

poiché è ereditato. Se istanziamo la sottoclasse, viene creata una copia dei membri della superclasse nell'oggetto della sottoclasse, quindi entrambi i metodi sono utilizzabili per gli oggetti della sottoclasse.

Ma, se si chiama il metodo(Esempio)se viene eseguito il metodo di esempio della sottoclasse per sovrascrivere il metodo della superclasse.

Esempio

class Super{
　　　public static void sample(){
　　　　　　System.out.println("Method of the superclass");
　　　}
}
public class OverridingExample extends Super {
　　　public static void sample(){
　　　　　　System.out.println("Method of the subclass");
　　　}
　　　public static void main(String args[]){
　　　　　　Super obj1 = (Super) new OverridingExample();
　　　　　　OverridingExample obj2 = new OverridingExample();
　　　　　　obj1.sample();
　　　　　　obj2.sample();
　　　}
}

Risultato di output

Method of the superclass
Method of the subclass

Sovrascrittura del metodo statico

Quando la superclasse e la sottoclasse contengono lo stesso metodo (inclusi i parametri) e se sono statici, il metodo nella superclasse viene nascosto dal metodo nella sottoclasse.

Questo meccanismo è abbreviato in "nascondimento del metodo", anche se la superclasse e la sottoclasse hanno metodi con la stessa firma statica, non vengono considerati come sovrascritti.

Esempio

class Super{
　　　public static void demo() {
　　　　　　System.out.println("Questo è il metodo principale della superclasse");
　　　}
}
class Sub extends Super{
　　　public static void demo() {
　　　　　　System.out.println("Questo è il metodo principale della sottoclasse");
　　　}
}
public class MethodHiding{}}
　　　public static void main(String args[]) {
　　　　　　MethodHiding obj = new MethodHiding();
　　　　　　Sub.demo();
　　　}
}

Risultato di output

Questo è il metodo principale della sottoclasse

Ragione del nascondimento del metodo

La chiave della sovraccarica dei metodi è che se la superclasse e la sottoclasse hanno metodi con la stessa firma, entrambi sono disponibili per l'oggetto della sottoclasse. Esegui il metodo corrispondente in base al tipo dell'oggetto utilizzato per salvare l'oggetto (referenza).

SuperClass obj1 = (Super) new SubClass();
obj1.demo() // chiama il metodo demo della superclasse
SubClass obj2 = new SubClass();
obj2.demo() // chiama il metodo demo della sottoclasse

Ma nel caso dei metodi statici, poiché non appartengono a nessuna istanza, è necessario accedere tramite il nome della classe.

SuperClass.demo();
SubClass.Demo();

Quindi, se la superclasse e la sottoclasse hanno metodi statici con la stessa firma, l'oggetto della sottoclasse può utilizzare la copia del metodo della superclasse. Poiché sono statici, la chiamata al metodo viene risolta automaticamente alla compilazione, quindi i metodi statici non possono essere sovrascritti.

Ma poiché è possibile utilizzare copie di metodi statici, se si chiama un metodo della sottoclasse, verrà ridefinito/nascosto il metodo della superclasse.