polymorphisme et interfaces

Question

si j'ai deux classes x et y, les deux étendent la classe w. et x l'implémentation de l'interface z. si j'ai des méthodes doSomething (w object) et doSomething (x object), que se passerait-il si j'appelais doSomething (x)?

éditer: im mettant en œuvre ce sur Java, plus spécifiquement sur android. Je pose cette question parce que certaines classes qui implémentent une interface spécifique font la même chose quand doSomething() est appelé. mais il y a des cas spéciaux que j'aimerais distinguer.

Answer 1

Disons que vous avez

w object1 = new x(); 
x object2 = new x(); 

Passing object1 exécutera et passant object2 doSomething(x object).

P.S: Bien sûr, en fonction de la langue (parlé C#)

P.P.S: Les noms de paramètres ajoutés pour la rendre plus claire

Answer 2

Vous ne pouvez pas avoir deux méthodes différentes avec les mêmes signatures. Son code ambigu, les compilateurs ne compileront pas et les interprètes jetteront une erreur.

Answer 3

Cela dépend de la langue que vous utilisez. Par exemple, en C#, il faudrait utiliser doSomething (x object) et non doSomething (w object).

Cependant, si vous casté à w il utiliserait doSomething (w objet) comme ceci:

doSomething((w) someObjectOfX); 

ou

doSomething(someObjectOfX as w); 

Answer 4

En C#, le compilateur choisir la bonne méthode en fonction sur le type déclaré de la variable, pas sur le type réel qui y est stocké.

Notez que le code ci-dessous déclare W comme classe et en construit une instance. Si vous faites W une interface, et supprimez sa déclaration et la construction, vous obtiendrez le même comportement pour x et y comme le programme ci-dessous, l'interface ou la classe W dans ce cas n'a pas d'importance.

Permettez-moi de vous montrer la différence:

using System; 

namespace SO2851194 
{ 
    class W { } 
    class X : W { } 
    class Y : W { } 

    class Program 
    { 
     static void Main() 
     { 
      W w = new W(); 
      X x = new X(); 
      Y y = new Y(); 

      doSomething(w); 
      doSomething(x); 
      doSomething(y); 
     } 

     static void doSomething(W w) 
     { 
      Console.Out.WriteLine("w"); 
     } 

     static void doSomething(X x) 
     { 
      Console.Out.WriteLine("x"); 
     } 
    } 
} 

Ici, je déclare trois variables, de type W, X et Y, et appelle doSomething passer les trois variables, un par un. La sortie de ce programme est le suivant:

w 
x 
w 

Comme prévu, le compilateur choisira la méthode qui a le meilleur type de paramètre d'ajustement, et dans le cas de la variable x, il a une méthode qui peut prendre un objet de tapez X.

Cependant, en raison de l'héritage de classe, nous pouvons changer la déclaration des variables, mais garder les types d'objets construits, donc changer le code comme ceci:

W w = new W(); 
W x = new X(); // Notice, changed variable type to W 
W y = new Y(); // but keep constructing X and Y 

Ce sorties maintenant:

w 
w 
w 

Donc le fait que la variable x contenait un objet de type X ne l'a pas pris en compte, le compilateur a choisi la méthode du type de variable, pas son contenu.

En C# 4.0, vous avez maintenant le type dynamic, donc changer à nouveau le code:

dynamic w = new W(); 
dynamic x = new X(); 
dynamic y = new Y(); 

sorties à nouveau:

w 
x 
w 

comme maintenant le compilateur REPORTE choisir aucune méthode jusqu'à ce que runtime, et à l'exécution, il voit que la variable nommée x contient effectivement un objet de type X, puis choisit la méthode avec le type de paramètre le mieux adapté.