Résolution de surcharge Java - Pourquoi m (cast, cast) au lieu de m (match, cast)

Question

Je suis assez sûr que je ne peux pas être le premier à trébucher dessus mais je ne trouve pas de réponse. C'est devoirs.

class Tier{} 

class Fisch extends Tier{} 

class Vogel extends Tier{} 

class Huhn extends Vogel{} 

class Spatz extends Vogel{} 

class Karpfen extends Fisch{} 

class Super{ 
    public void m(Tier t1, Tier t2){ 
     System.out.println("1"); 
    } 

    public void m(Tier t, Fisch f){ 
     System.out.println("2"); 
    } 

    public void m(Fisch f, Tier t){ 
     System.out.println("5"); 
    } 
} 

class Sub extends Super{ 
    public void m(Tier t1, Fisch t2){ 
     System.out.println("3"); 
    } 

    public void m(Vogel v, Fisch f){ 
     System.out.println("4"); 
    } 
} 


public class TierTest{ 
    public static void main(String[] args) { 
     Tier t1 = new Tier(); 
     Tier t2 = new Vogel(); 
     Fisch f = new Karpfen(); 
     Vogel v1 = new Vogel(); 
     Vogel v2 = new Spatz(); 
     Huhn h = new Huhn(); 
     Karpfen k = new Karpfen(); 

     Super sup1 = new Super(); 
     Super sup2 = new Sub(); 

     sup1.m(h, v2); 
     sup2.m(v1, k); //4 expected, got 3 
     sup1.m(t1, t2); 
     sup1.m(v1, k); 
     sup1.m(v2, f); 
     sup2.m(v1, f); //4 expected, got 3 
    } 
} 

Les deux fois un Vogel (oiseau) (déclaration et type d'exécution) et une sorte de poisson. Pourquoi m (Tier, Fisch) est-il choisi sur m (Vogel, Fisch)?

Le premier paramètre correspond parfaitement. Le reste de ceci correspond à mon intuition. Désolé, je suis trop engourdi pour trouver une question similaire.

un week-end agréable, Stephan

Answer 1

ici:

Vogel v1 = new Vogel();     
Karpfen k = new Karpfen(); 
... 
Super sup2 = new Sub(); 
... 
sup2.m(v1, k); //4 expected, got 3 

sup2 est déclarée avec le type de classe Super.
La méthode choisie par le compilateur repose sur la classe de la variable déclarée, pas sur l'instance d'exécution. Par conséquent, les compilateurs recherchent une méthode qui correspond à la classe Super.

Dans Super classe, ce sont les m() candidats méthode potentiels:

public void m(Tier t1, Tier t2){ 
    System.out.println("1"); 
} 

public void m(Tier t, Fisch f){ 
    System.out.println("2"); 
} 

public void m(Fisch f, Tier t){ 
    System.out.println("5"); 
} 

Le compilateur choisit la méthode la plus spécifique entre autres pour correspondre avec v1 et k arguments types déclarés:

Cette méthode est sélectionnée :

public void m(Tier t, Fisch f){ 
    System.out.println("2"); 
} 

Maintenant, lors de l'exécution, la méthode est invoqué sur l'objet d'exécution (principe de polymorphisme).
Comme la classe d'exécution que la variable sup2 fait référence est Sub, la méthode surchargée de Sub est invoquée:

public void m(Tier t1, Fisch t2){ 
    System.out.println("3"); 
} 

Et pour cette seconde invocation:

sup2.m(v1, f); //4 expected, got 3 

Il est exactement le même raisonnement.