Que fait Base b2 = new Child(); signifier?

Question

class Base { 

    public void add() { 
     System.out.println("Base ADD"); 
    } 

    void subtract() { 
     throw new UnsupportedOperationException("Not yet implemented"); 
    } 

} 

class Child extends Base { 

    public void add(){ 
     System.out.println("Child ADD"); 
    } 

    public void subtract() { 
     System.out.println("Child Subtract"); 
    } 

} 

class MainClass { 

    public static void main(String args[]) { 

     Base b1 = new Base(); 
     Base b2 = new Child(); 

     Child b3 = new Child(); 

     b1.add(); 

     b2.subtract(); 

     b2.add(); 
     b3.subtract(); 

    } 

} 

Je suis quelque peu confus avec le code ci-dessus. La ligne la plus déroutante me est

Base b2 = new Child(); 

et

b2.subtract(); 

Ce que je comprends est au moment de la compilation compilateur vérifie la météo Base classe a subtract() méthode ou pas, au polymorphisme d'exécution d'exécution se produit comme objet est de type Child.

La question est de savoir comment ou où l'on peut utiliser cette ligne à savoir Base b2 = new Child();

Dans ce scénario, nous devrions utiliser? S'il vous plaît, aidez, ce serait génial!

Answer 1

Regardez les deux parties de la déclaration:

Base b2 

que déclare une variable appelée b2 de type Base. Vous pouvez affecter une référence à cette variable si la référence est null ou fait référence à une instance de Base ou à une sous-classe de Base.

Puis

new Child() 

crée une nouvelle instance de Child. Child est une sous-classe de Base, de sorte que vous pouvez affecter la référence renvoyée par le constructeur à la variable b2. Maintenant, vous ne pouvez "voir" que les membres de Base à b2, même si la valeur réelle fait référence à une instance de Child au moment de l'exécution. Mais les méthodes de Base qui ont été surchargées dans Child utiliseront la version surchargée quand on les appelle ... alors quand vous appelez

b2.subtract(); 

la machine virtuelle Java découvre le type réel de l'objet b2 se réfère à, et utilise l'implémentation de cette classe de subtract - dans ce cas, la méthode qui imprime "Child Subtract".

EDIT: Vous avez spécifiquement demandé où vous pouvez utiliser ce genre de chose, et comment il aide ...

Vous pouvez l'utiliser chaque fois que vous voulez déclarer une variable d'un type plus général (un superclasse ou une interface) mais lui assigner une valeur qui se trouve être une sous-classe ou une implémentation de l'interface. Autre exemple:

List<String> strings = new ArrayList<String>(); 

Le principal avantage de déclarer une variable d'une manière générale est que vous conservant une certaine souplesse - plus tard, vous pouvez changer d'utiliser ArrayList<T> à une autre mise en œuvre de List<T>, et le code devrait tout de même travail. Vous dites essentiellement: «J'ai seulement besoin des membres et des garanties fournies par List<T> - le fait que j'utilise ArrayList<T> est quelque peu accessoire. Un exemple similaire est de décider du type de méthode à renvoyer. Souvent, vous voulez déclarer que vous renvoyez un type général (ou une interface) même si l'implémentation connaît le type concret renvoyé. Cela cache les détails de l'implémentation, ce qui vous permet de les changer plus tard.

Answer 2

Base b2 = new Child(); 

Vous pouvez utiliser Référence de Super pour l'objet de l'enfant.

pour b2.méthode();

Lors de la compilation, vous devez avoir la méthode(); dans BaseClass.

Au moment de l'exécution de la méthode de l'objet va s'invoqué ici si l'objet est Enfant de Base b2 = new Child();

Ainsi version enfant method() va s'exécuter.

Utilisation:

Polymorphisme est extrêmement utile dans la conception de systèmes au niveau de l'entreprise, comme vous pouvez créer et définir plusieurs couches d'interface qui permettent aux parties externes ou logiciels en dehors d'interagir avec votre système d'une manière particulière . Nous savons tous à quel point il est utile dans l'intégration de systèmes d'avoir une API publiée, mais si des modifications du système interne deviennent nécessaires, l'API peut devoir être republiée et les systèmes intégrés doivent être retravaillés. Pour éviter cela, une attention particulière doit être accordée aux API objet ainsi qu'aux API système globales lors de la conception. Une façon de s'assurer qu'un système robuste peut traiter des objets qui ont des méthodologies plus complexes que ce qui était initialement prévu est de faire polymorphiser l'API de l'objet. De cette façon, le système connaît une "face" de l'objet qui lui est transmis, mais n'a pas besoin d'être conscient des changements extemporanés.

Voir aussi

• Standard Docs on Polymorphism
• Resource