Perché questi due esempi di codice producono output diversi?

Question

Esempio 1:

class Animal { 
    public static void saySomething() { System.out.print(" Gurrr!"); 
    } 
} 
class Cow extends Animal { 
    public static void saySomething() { 
    System.out.print(" Moo!"); 
    } 
    public static void main(String [] args) { 
     Animal [] animals = {new Animal(), new Cow()}; 
     for(Animal a : animals) { 
      a.saySomething(); 
     } 
     new Cow().saySomething(); 
    } 
} 

uscita è:

Gurrr! Gurrr! Moo! 

Esempio 2:

class Animal { 
    public void saySomething() { System.out.print(" Gurrr!"); 
    } 
} 
class Cow extends Animal { 
    public void saySomething() { 
    System.out.print(" Moo!"); 
    } 
    public static void main(String [] args) { 
     Animal [] animals = {new Animal(), new Cow()}; 
     for(Animal a : animals) { 
      a.saySomething(); 
     } 
     new Cow().saySomething(); 
    } 
} 

uscita:

Gurrr! Moo! Moo! 

io proprio non capisco perché fare saySomething non-stat ic causa la seconda chiamata a sayqualcosa che richiama la versione Cow invece della versione Animal. La mia comprensione era che il Gurrr! Moo! Moo! sarebbe stato l'output in entrambi i casi.

Answer 1

I metodi statici sono legati alla loro classe in fase di compilazione e non possono essere utilizzati in modo polimorfico. Quando dichiari un metodo "statico" su Animal, è legato per sempre alla classe Animal e non può essere sovrascritto. I metodi statici sono legati all'oggetto Class, non a un'istanza della classe.

I metodi regolari sono associati in fase di esecuzione e pertanto la JVM può visualizzare la chiamata su "say Something" e tentare di determinare se si sta passando attorno ad una sottoclasse di Animal e, in caso affermativo, ha sostituito il metodo saySomething(). I metodi regolari sono legati a un'istanza di un oggetto, non alla classe stessa.

Anche per questo motivo non si poteva mai fare questo:

class Animal 
{ 
    public abstract static void saySomething(); 
} 

Dal significa "statiche", "legate al momento della compilazione", non ha mai senso per qualcosa di cui essere statico e astratto.

Answer 2

Quando si chiama saySomething() su un animale, il tipo effettivo dell'animale non conta perché saySomething() è statico.

Animal cow = new Cow(); 
cow.saySomething(); 

è uguale

Animal.saySomething(); 

---

Un esempio JLS:

Quando viene calcolato un riferimento di destinazione e poi scartata poiché la modalità invocazione è statico, il riferimento è non esaminato per vedere se è nullo:

class Test { 
    static void mountain() { 
     System.out.println("Monadnock"); 
    } 
    static Test favorite(){ 
     System.out.print("Mount "); 
     return null; 
    } 
    public static void main(String[] args) { 
     favorite().mountain(); 
    } 

}

che stampa:
Monte Monadnock
Qui preferita torna nulla, eppure nessuno NullPointerException è gettato.

---

Risorse:

• JLS - Is the Chosen Method Appropriate?

Sullo stesso argomento:

• Java Static confusion

Answer 3

Non è possibile di override metodi statici con la stessa firma in sottoclassi, basta nasconderli.

Per metodi di classe, il sistema runtime invoca il metodo definito nel tipo fase di compilazione del riferimento su cui viene chiamato il metodo. Ad esempio, il sistema runtime richiama il metodo definito nel tipo di runtime del riferimento su cui viene chiamato il metodo.

http://life.csu.edu.au/java-tut/java/javaOO/override.html

Answer 4

Alcune delle note di priorità assoluta "trappole"

• metodi statici non possono essere invocati
• metodi privati ​​non possono essere ridefinite

Questo spiega l'output.

Answer 5

I metodi statici sono legati alla "Classe", non all'istanza dell'oggetto. Poiché ci si riferisce a un "Animale" e si chiama il metodo statico say Something(). Farà sempre la chiamata a "Animal" a meno che non ti riferisca a una mucca.