Java Language Eredità statica


Esempio

Il metodo statico può essere ereditato in modo simile ai metodi normali, tuttavia a differenza dei metodi normali è impossibile creare metodi " astratti " per forzare l'override del metodo statico. Scrivere un metodo con la stessa firma di un metodo statico in una super classe sembra essere una forma di sovrascrittura, ma in realtà ciò crea semplicemente una nuova funzione che nasconde l'altro.

public class BaseClass {
    
    public static int num = 5;

    public static void sayHello() {
        System.out.println("Hello");
    }

    public static void main(String[] args) {
        BaseClass.sayHello();
        System.out.println("BaseClass's num: " + BaseClass.num);
            
        SubClass.sayHello();
        //This will be different than the above statement's output, since it runs
        //A different method
        SubClass.sayHello(true);
        
        StaticOverride.sayHello();
        System.out.println("StaticOverride's num: " + StaticOverride.num);
    }
}

public  class SubClass extends BaseClass {
    
    //Inherits the sayHello function, but does not override it   
    public static void sayHello(boolean test) {
        System.out.println("Hey");
    }
}

public static class StaticOverride extends BaseClass {

    //Hides the num field from BaseClass
    //You can even change the type, since this doesn't affect the signature
    public static String num = "test";
        
    //Cannot use @Override annotation, since this is static
    //This overrides the sayHello method from BaseClass
    public static void sayHello() {
        System.out.println("Static says Hi");
    }

}

L'esecuzione di una di queste classi produce l'output:

Hello
BaseClass's num: 5
Hello
Hey
Static says Hi
StaticOverride's num: test

Si noti che, a differenza dell'ereditarietà normale, i metodi di ereditarietà statica non sono nascosti. Puoi sempre chiamare il metodo sayHello base usando BaseClass.sayHello() . Ma le classi ereditano metodi statici se nella sottoclasse non vengono trovati metodi con la stessa firma. Se le firme di due metodi variano, entrambi i metodi possono essere eseguiti dalla sottoclasse, anche se il nome è lo stesso.

I campi statici si nascondono l'un l'altro in modo simile.