Stavo leggendo la Guida di un programmatore alla certificazione SCJP Java ™ di Khalid Mughal.

Nel capitolo Ereditarietà, questo spiega

L'eredità dei membri è strettamente legata alla loro accessibilità dichiarata. Se un membro della superclasse è accessibile con il suo nome semplice nella sottoclasse (senza l'uso di alcuna sintassi aggiuntiva come super), quel membro viene considerato ereditato

Indica anche che i metodi statici non sono ereditati. Ma il codice qui sotto è perfettamente perfetto:

class A
{
    public static void display()
    {
        System.out.println("Inside static method of superclass");
    }
}

class B extends A
{
    public void show()
    {
        // This works - accessing display() by its simple name -
        // meaning it is inherited according to the book.
        display();
    }
}

Come posso utilizzare direttamente display()in classe B? Ancora di più, B.display()funziona anche.

La spiegazione del libro si applica solo ai metodi di istanza?

Tutti i metodi accessibili sono ereditati da sottoclassi.

Dai tutorial Java Sun :

Una sottoclasse eredita tutti i membri pubblici e protetti del suo genitore, indipendentemente dal pacchetto in cui si trova la sottoclasse. Se la sottoclasse si trova nello stesso pacchetto del suo genitore, eredita anche i membri pacchetto-privati ​​del genitore. È possibile utilizzare i membri ereditati così come sono, sostituirli, nasconderli o integrarli con nuovi membri

L'unica differenza con i metodi statici (di classe) ereditati e i metodi non statici (di istanza) ereditati è che quando si scrive un nuovo metodo statico con la stessa firma, il vecchio metodo statico viene semplicemente nascosto, non ignorato.

Dalla pagina sulla differenza tra ignorare e nascondere.

La distinzione tra nascondere e ignorare ha importanti implicazioni. La versione del metodo ignorato che viene invocato è quella nella sottoclasse. La versione del metodo nascosto che viene invocato dipende dal fatto che sia invocato dalla superclasse o dalla sottoclasse

Se è quello che dice davvero il libro, è sbagliato. [1]

La specifica del linguaggio Java # 8.4.8 afferma:

8.4.8 Ereditarietà, sostituzione e occultamento

Una classe C eredita dalla sua superclasse diretta tutti i metodi concreti m (sia statici che di istanza) della superclasse per i quali sono vere tutte le seguenti condizioni:

• m è un membro della superclasse diretta di C.

• m è pubblico, protetto o dichiarato con accesso al pacchetto nello stesso pacchetto di C.

• Nessun metodo dichiarato in C ha una firma che è una sottoscrizione (§8.4.2) della firma di m.

[1] Non lo dice nella mia copia, prima edizione, 2000.

Puoi notare la differenza nel seguente codice, che è leggermente modificato rispetto al tuo codice.

class A {
    public static void display() {
        System.out.println("Inside static method of superclass");
    }
}

class B extends A {
    public void show() {
        display();
    }

    public static void display() {
        System.out.println("Inside static method of this class");
    }
}

public class Test {
    public static void main(String[] args) {
        B b = new B();
        // prints: Inside static method of this class
        b.display();

        A a = new B();
        // prints: Inside static method of superclass
        a.display();
    }
}

Ciò è dovuto ai metodi statici sono metodi di classe.

A.display () e B.display () chiameranno il metodo delle rispettive classi.

B.display () funziona perché la dichiarazione statica fa sì che il metodo / membro appartenga alla classe e non a nessuna istanza di classe particolare (aka Object). Puoi leggere di più qui .

Un'altra cosa da notare è che non puoi ignorare un metodo statico, puoi far dichiarare alla tua sottoclasse un metodo statico con la stessa firma, ma il suo comportamento potrebbe essere diverso da quello che ti aspetteresti. Questo è probabilmente il motivo per cui non è considerato ereditato. Puoi controllare lo scenario problematico e la spiegazione qui .

I metodi statici in Java sono ereditati, ma non possono essere ignorati. Se si dichiara lo stesso metodo in una sottoclasse, si nasconde il metodo della superclasse invece di sovrascriverlo. I metodi statici non sono polimorfici. Al momento della compilazione, il metodo statico sarà collegato staticamente.

Esempio:

public class Writer {
    public static void write() {
        System.out.println("Writing");
    }
}

public class Author extends Writer {
    public static void write() {
        System.out.println("Writing book");
    }
}

public class Programmer extends Writer {

    public static void write() {
        System.out.println("Writing code");
    }

    public static void main(String[] args) {
        Writer w = new Programmer();
        w.write();

        Writer secondWriter = new Author();
        secondWriter.write();

        Writer thirdWriter = null;
        thirdWriter.write();

        Author firstAuthor = new Author();
        firstAuthor.write();
    }
}

Otterrai quanto segue:

Writing
Writing
Writing
Writing book

I metodi statici sono ereditati in Java ma non prendono parte al polimorfismo. Se tentiamo di sovrascrivere i metodi statici, nasconderanno semplicemente i metodi statici della superclasse invece di sovrascriverli.

Questo concetto non è così semplice come sembra. Possiamo accedere ai membri statici senza ereditarietà, che è relazione HasA. Possiamo accedere ai membri statici estendendo anche la classe genitore. Ciò non implica che si tratti di una relazione ISA (ereditarietà). I membri statici in realtà appartengono alla classe e static non è un modificatore di accesso. Finché i modificatori di accesso consentono di accedere ai membri statici, possiamo usarli in altre classi. Come se fosse pubblico, sarà accessibile all'interno dello stesso pacchetto e anche al di fuori del pacchetto. Per privati ​​non possiamo usarlo da nessuna parte. Per impostazione predefinita, possiamo usarlo solo all'interno del pacchetto. Ma per proteggere dobbiamo estendere la super classe. Quindi ottenere il metodo statico su un'altra classe non dipende dall'essere statico. Dipende dai modificatori di accesso. Quindi, secondo me, I membri statici possono accedere se i modificatori di accesso lo consentono. Altrimenti, possiamo usarli come usiamo dalla relazione Hasa. E ha una relazione non ereditaria. Ancora una volta non possiamo ignorare il metodo statico. Se possiamo usare un altro metodo ma non possiamo ignorarlo, allora è relazione HasA. Se non riusciamo a sovrascriverli non sarà eredità, quindi lo scrittore era corretto al 100%.

Il metodo statico è ereditato in una sottoclasse ma non è polimorfismo. Quando si scrive l'implementazione del metodo statico, il metodo della classe del genitore viene nascosto, non sovrascritto. Pensa, se non è ereditato, come puoi accedere senza classname.staticMethodname();?

Tutti i membri pubblici e protetti possono essere ereditati da qualsiasi classe, mentre i membri predefiniti o del pacchetto possono anche essere ereditati dalla classe all'interno dello stesso pacchetto di quello della superclasse. Non dipende se si tratta di un membro statico o non statico.

È anche vero che la funzione di membro statico non prende parte all'associazione dinamica. Se la firma di quel metodo statico è la stessa sia nella classe genitore che in quella figlio, si applica il concetto di Shadowing, non il polimorfismo.

Puoi sovrascrivere i metodi statici, ma se provi a usare il polimorfismo, allora funzionano secondo lo scopo della classe (Contrariamente a quanto normalmente ci aspettiamo).

public class A {

    public static void display(){
        System.out.println("in static method of A");
    }
}

public class B extends A {

    void show(){
        display();
    }

     public static void display(){
        System.out.println("in static method of B");
    }

}
public class Test {

    public static void main(String[] args){
        B obj =new B();
        obj.show();

        A a_obj=new B();
        a_obj.display();


    }


}

Nel primo caso, o / p è il "nel metodo statico di B" # override riuscito Nel 2 ° caso, o / p è "nel metodo statico di A" # Metodo statico - non prenderà in considerazione il polimorfismo

Possiamo dichiarare metodi statici con la stessa firma nella sottoclasse, ma non è considerato prioritario in quanto non ci sarà alcun polimorfismo di runtime. Poiché tutti i membri statici di una classe vengono caricati al momento del caricamento della classe, quindi decide al momento della compilazione time (override in run time) Quindi la risposta è 'No'.

Molti hanno espresso la loro risposta a parole. Questa è una spiegazione estesa nei codici:

public class A {
    public static void test() {
        System.out.println("A");
    }
    public static void test2() {
        System.out.println("Test");
    }
}

public class B extends A {
    public static void test() {
        System.out.println("B");
    }
}

// Called statically
A.test();
B.test();
System.out.println();

// Called statically, testing static inheritance
A.test2();
B.test2();
System.out.println();

// Called via instance object
A a = new A();
B b = new B();
a.test();
b.test();
System.out.println();

// Testing inheritance via instance call
a.test2();
b.test2();
System.out.println();

// Testing whether calling static method via instance object is dependent on compile or runtime type
((A) b).hi();
System.out.println();

// Testing whether null instance works
A nullObj = null;
nullObj.hi();

risultati:

A
B

Test
Test

A
B

Test
Test

A

A

Pertanto, questa è la conclusione:

1. Quando chiamiamo lo statico in modo statico tramite., Cercherà lo statico definito in quella classe, o la classe più vicina a quella nella catena di ereditarietà. Ciò dimostra che i metodi statici sono ereditati.
2. Quando viene chiamato un metodo statico da un'istanza, chiama il metodo statico definito nel tipo di tempo di compilazione.
3. Il metodo statico può essere chiamato da nullun'istanza. La mia ipotesi è che il compilatore utilizzerà il tipo di variabile per trovare la classe durante la compilazione e tradurla nella chiamata del metodo statico appropriato.

I membri statici sono membri universali. Sono accessibili da qualsiasi luogo.

I membri statici non verranno ereditati nella sottoclasse perché l'ereditarietà è solo per i membri non statici. I membri statici verranno caricati all'interno del pool statico dal caricatore di classi. L'ereditarietà è solo per quei membri che sono caricati all'interno dell'oggetto