Comment le polymorphisme rend-il mon code plus flexible?

Question

Je suis de la lecture , la Tête la Première Conception Orientée Objet pour obtenir une meilleure compréhension des concepts de programmation orientée objet.

Le polymorphisme est expliqué que:

Airplane plane = new Airplane();
Airplane plane = new Jet();
Airplane plane = new Rocket();

Vous pouvez écrire du code qui fonctionne sur la super-classe, comme un avion, mais fonctionne avec tout les sous-classes. :- * Hmmm.. ..j'ai eu celui-là.*.

Il explique en outre:

-> Alors, comment ne polymorphisme rend le code flexible?

Eh bien, si vous avez besoin d'une nouvelle fonctionnalité, vous pouvez écrire une nouvelle sous-classe de En avion. Mais depuis votre code utilise la super-classe, votre nouvelle classe travail sans aucun changement pour le reste de votre code.

Maintenant, je ne suis pas à l'obtenir. J'ai besoin de créer un sublass d'un avion. Par exemple: je crée une classe, Randomflyer. Pour l'utiliser, je vais avoir à créer son objet. Donc, je vais utiliser:

Airplane plane = new Randomflyer();

Je ne suis pas à l'obtenir. Même moi, j'aurais créé un objet d'une sous-classes directement. Je ne vois pas la nécessité de changer mon code n'importe où quand je vais ajouter une nouvelle sous-classe. Comment à l'aide d'une super-classe sauve-moi de faire des modifications supplémentaires pour le reste de mon code?

Answer 1

Dire que vous avez l'suivantes (simplifié):

Airplane plane = new MyAirplane();

Ensuite à vous de faire toutes sortes de choses avec elle:

List<Airplane> formation = ...
// superclass is important especially if working with collections
formation.add(plane);
// ...
plane.flyStraight();
plane.crashTest();
// ... insert some other thousand lines of code that use plane

Chose est. Lorsque vous décidez subitement de changer votre plan de

Airplane plane = new PterdodactylSuperJet();

tous vos autres code que j'ai écrit ci-dessus tout fonctionne (différemment, bien sûr) parce que l'autre code s'appuie sur l'interface (lire:les méthodes publiques) fournis par le général Airplane classe, et non pas à partir de la mise en œuvre effective de vous fournir, au début. De cette façon, vous pouvez passer sur les différentes mises en œuvre sans modifier votre code.

Si vous n'avez pas utilisé un Airplane superclasse et juste écrit MyAirplane et PterdodactylSuperJet dans le sens que vous remplacer

MyAriplane plane = new MyAirplane();

avec

PterdodactylSuperJet plane = new PterdodactylSuperJet();

ensuite, vous avez raison sur un point: le reste de votre code peut encore travailler. Mais que se passe juste à travailler, parce que vous avez écrit la même interface (méthodes publiques) dans les deux classes, sur le but. Si vous (ou une autre dev) la modification de l'interface dans une classe, aller-retour entre l'avion classes de rendre votre code inutilisable.

Modifier

Par sur le but , je veux dire que vous avez spécifiquement de mettre en œuvre des méthodes, avec les mêmes signatures dans les deux MyAirplane et PterodactylSuperJet pour que votre code fonctionne correctement avec les deux. Si vous ou quelqu'un de changer l'interface d'une classe, votre flexibilité est cassé.

Exemple. Dites que vous n'avez pas l' Airplane super-classe et une autre sans méfiance dev modifie la méthode

public void flyStraight()

en MyAirplane de

public void flyStraight (int speed)

et supposons que votre plane variable est de type MyAirplane. Puis la code aurait besoin de quelques modifications; supposer que ce qui est nécessaire de toute façon. La chose est, si vous revenez à un PterodactylSuperJet (par exemple, pour le tester, comparer, une pléthore de raisons), votre code ne sera pas exécuté. Whygodwhy. Parce que vous avez besoin pour fournir de l' PterodactylSuperJet avec la méthode flyStraight(int speed) vous n'avez pas écrit. Vous pouvez le faire, vous pouvez le réparer, c'est bien.

C'est un simple scénario. Mais que faire si

• Ce problème vous pique dans le cul d'un an après l'innocent modification? Vous pourriez même oublier pourquoi vous l'avez fait dans la première place.
• Pas un, mais une tonne de modificatios avait eu lieu que vous ne pouvez pas garder une trace de? Même si vous pouvez garder la trace, vous avez besoin pour obtenir la nouvelle classe jusqu'à la vitesse. Presque jamais facile et certainement jamais agréable.
• Au lieu de deux classes d'avions vous avez une centaine?
• Linéaire (ou non) une combinaison de ce qui précède?

Si vous aviez écrit un Airplane de la superclasse et fait de chaque sous-classe de remplacer ses méthodes pertinentes, puis en changeant flyStraight() de flyStraight(int) en Airplane vous seriez obligés de s'adapter à toutes les sous-classes en conséquence, par conséquent, de garder la cohérence. La flexibilité ne sera donc pas être modifié.

Fin edit

C'est pourquoi une super-classe reste comme une sorte de "papa" dans le sens que si une personne modifie son interface, toutes les classes vont suivre, par conséquent, votre code sera plus souple.

Answer 2

Très simple d'utilisation-cas à démontrer les avantages de polymorphisme est le traitement par lots d'une liste d'objets, sans vraiment se soucier de son type (c'est à dire de déléguer cette responsabilité à chaque type de béton). Cela permet d'effectuer opérations abstraites de façon constante sur une collection d'objets.

Disons que vous souhaitez mettre en place une simulation de programme de vol, l'endroit où vous voulez voler chaque type d'avion qui est présent dans votre liste. Il vous suffit d'appeler

for (AirPlane p : airPlanes) {
    p.fly();
}

Chaque avion sait comment voler lui-même, et vous n'avez pas besoin de vous soucier du type de la des avions, tout en faisant de cet appel. Cette uniformité dans le comportement des objets est ce que le polymorphisme vous donne.

Answer 3

Supposons que vous avez des méthodes dans votre Contrôleur de classe d'Avions

parkPlane(Airplane plane)

et

servicePlane(Airplane plane)

mis en œuvre dans votre programme. Il ne sera pas BRISER votre code. Je veux dire, il n'a pas besoin de changer tant qu'il accepte les arguments de la AirPlane.

Parce qu'il acceptera n'importe quel Avion en dépit de type réel, flyer, highflyr, fighter, etc.

Aussi, dans une collection:

List<Airplane> plane; // Va prendre tous vos plans.

L'exemple suivant permettra de effacer de votre compréhension.

---

interface Airplane{
    parkPlane();
    servicePlane();
}

Maintenant vous avez un avion de chasse qui l'implémente, de sorte

public class Fighter implements Airplane {

    public void  parkPlane(){
        // Specific implementations for fighter plane to park
    }
    public void  servicePlane(){
        // Specific implementatoins for fighter plane to service.
    }
}

La même chose pour les Aventureux et les autres clasess:

public class HighFlyer implements Airplane {

    public void  parkPlane(){
        // Specific implementations for HighFlyer plane to park
    }

    public void  servicePlane(){
        // specific implementatoins for HighFlyer plane to service.
    }
}

Maintenant, pensez à votre contrôleur de classes à l'aide d' AirPlane plusieurs fois,

Supposons que votre Contrôleur de classe est ControlPlane comme ci-dessous,

public Class ControlPlane{ 
 AirPlane plane;
 **//lots of method with lots of AirPlane references are used here**
}

ici, la magie opère comme Polymorphisme rend votre code plus souple car,

vous pouvez faire de votre nouveau AirPlane type de cas, comme beaucoup que vous le souhaitez et vous n'êtes pas changer

code de l' ControlPlane classe.

vous pouvez ajouter une instance..

JumboJetPlane // implementing AirPlane interface.
AirBus        // implementing AirPlane interface.

vous pouvez supprimer les instances.. déjà créé des types trop.

Answer 4

D'autres personnes ont plus de remédier pleinement à vos questions sur le polymorphisme en général, mais je tiens à répondre à une partie spécifique:

Je ne suis pas le faire, même que j'aurais pu créer un objet de sous-classes directement.

C'est en fait une grosse affaire, et les gens vont à beaucoup d'efforts pour éviter de le faire. Si vous craquez ouvrir quelque chose comme la "bande des Quatre", il y a un tas de modèles dédiés à la juste éviter ce problème.

La principale méthode est appelée le modèle de Fabrique. Qui ressemble à quelque chose comme ceci:

AirplaneFactory factory = new AirplaneFactory();

Airplane planeOne = factory.buildAirplane();
Airplane planeTwo = factory.buildJet();
Airplane planeThree = factory.buildRocket();

Cela vous donne plus de flexibilité par l'abstraction l' instanciation de l'objet. On pourrait imaginer une situation comme celle-ci: votre entreprise commence principalement la construction Jets, de sorte que votre usine a un buildDefault() méthode qui ressemble à ceci:

public Airplane buildDefault() {
    return new Jet();
}

Un jour, votre patron vient à vous et vous dit que l'entreprise a changé. Ce que les gens veulent vraiment ces jours sont Rockets - Jets sont une chose du passé.

Sans l' AirplaneFactory, vous auriez à passer par votre code et remplacer éventuellement des dizaines d'appels d' new Jet() avec new Rocket(). Avec le modèle de Fabrique, vous pouvez simplement faire un changement comme:

public Airplane buildDefault() {
    return new Rocket();
}

et donc l'étendue de la modification est considérablement réduit. Et puisque vous avez été le codage de l'interface Airplane plutôt que le type de béton Jet ou Rocket, c'est la seule modification que vous souhaitez apporter.

Answer 5

Comme je le comprends, l'avantage est que, par exemple, dans un avion de combat du jeu, vous devez mettre à jour tous les avions de positions à chaque boucle, mais vous avez le choix entre plusieurs avions. Disons que vous avez:

• MiG-21
• Waco 10
• Mitsubishi Zéro
• Eclipse 500
• Mirage

Vous ne voulez pas avoir à mettre à jour leurs mouvements et les positions séparées, comme ceci:

Mig21 mig = new Mig21();
mig.move();
Waco waco = new Waco();
waco.move();
Mitsubishi mit = new Mitsubishi();
mit.move();
...

Vous voulez avoir une super-classe qui peut prendre n'importe quelle de ce sous-classes (Avion) et de mettre à jour le tout dans une boucle:

airplaneList.append(new Mig21());
airplaneList.append(new Waco());
airplaneList.append(new Mitsubishi());
...
for(Airplane airplane : airplanesList)
    airplane.move()

Cela rend votre code beaucoup plus simple.