Pourquoi utiliser le polymorphism?

Voyons d’abord la conception OO, l’inheritance représente une relation IS-A, généralement nous pouvons dire quelque chose comme “laisser voler nos FlyingMachines “. chaque FlyingMachines spécifique (sous-classe) IS-A FlyingMachines (classe mère), disons Jet , correspond à cette “laisser notre FlyingMachines voler”, alors que nous voulons que ce vol soit réellement la fonction de vol du spécifique (sous-classe), c’est du polymorphism prendre le contrôle.

donc nous faisons les choses de manière abstraite, les interfaces orientées et la classe de base, ne dépendent pas réellement de la mise en œuvre détaillée, le polymorphism fera la bonne chose!

Dans votre exemple, l’utilisation du polymorphism n’est pas très utile car vous n’avez qu’une seule sous-classe de FlyingMachine . Le polymorphism devient utile si vous avez plusieurs types de FlyingMachine . Vous pourriez alors avoir une méthode qui accepte n’importe quel type de FlyingMachine et qui utilise sa méthode fly() . Un exemple pourrait être testMaxAltitude(FlyingMachine) .

Une autre fonctionnalité disponible uniquement avec le polymorphism est la possibilité d’avoir une List et de l’utiliser pour stocker Jet , Kite ou VerySmallPebbles .

L’un des meilleurs exemples de polymorphism est la possibilité de faire référence à des interfaces plutôt qu’à des implémentations.

Par exemple, il est préférable d’avoir une méthode qui retourne sous la forme List plutôt qu’une ArrayList . De cette façon, je peux changer mon implémentation dans la méthode en LinkedList ou Stack sans casser aucun code utilisant ma méthode.

La raison pour laquelle vous utilisez le polymorphism, c’est lorsque vous construisez des frameworks génériques qui prennent tout un tas d’objects différents avec la même interface . Lorsque vous créez un nouveau type d’object, vous n’avez pas besoin de modifier le cadre pour l’adapter au nouveau type d’object, tant qu’il suit les “règles” de l’object.

Ainsi, dans votre cas, un exemple plus utile consiste à créer un type d’object “Airport” qui accepte différents types de FlyingMachines. L’aéroport définira une fonction “AllowPlaneToLand”, semblable à:

 //pseudocode void AllowPlaneToLand(FlyingMachine fm) { fm.LandPlane(); } 

Tant que chaque type de FlyingMachine définit une méthode LandPlane appropriée, il peut se poser correctement. L’aéroport n’a pas besoin de savoir quoi que ce soit sur la FlyingMachine, sauf que pour atterrir, il doit invoquer LandPlane sur la FlyingMachine. Ainsi, l’aéroport n’a plus besoin de changer et peut continuer à accepter de nouveaux types de FlyingMachines, qu’il s’agisse d’un handglider, d’un OVNI, d’un parachute, etc.

Le polymorphism est donc utile pour les frameworks construits autour de ces objects, qui peuvent accéder de manière générique à ces méthodes sans avoir à changer.

Quel est l’avantage du polymorphism lorsque flm.fly() et j.fly() me donnent la même réponse?

L’avantage est que

 FlyingMachines flm = new Jet(); flm.fly(); 

résultats

 "Start, Taxi, Fly" 

au lieu de

 "No implementation" 

C’est du polymorphism. Vous appelez fly() sur un object de type FlyingMachine et il sait toujours qu’il s’agit en fait d’un Jet et appelle la méthode fly() appropriée au lieu de la mauvaise méthode qui affiche "No implementation" .

Cela signifie que vous pouvez écrire des méthodes qui fonctionnent avec des objects de type FlyingMachine et les alimenter avec toutes sortes de sous-types tels que Jet ou Helicopter et ces méthodes feront toujours ce qu’il faut, c’est-à-dire appeler la méthode fly() du type approprié au lieu de toujours le faire. la même chose, c’est-à-dire la sortie "No implementation".

Polymorphisme

Le polymorphism n’est pas utile dans votre exemple.

• a) Cela devient utile lorsque vous avez différents types d’objects et que vous pouvez écrire des classes qui peuvent fonctionner avec tous ces différents types, car ils adhèrent tous à la même API.

• b) Cela devient également utile lorsque vous pouvez append de nouvelles FlyingMachine à votre application sans modifier la logique existante.

a) et b) sont les deux faces d’une même pièce.

Laisse moi montrer comment.

Exemple de code

 import java.util.ArrayList; import java.util.List; import static java.lang.System.out; public class PolymorphismDemo { public static void main(Ssortingng[] args) { List machines = new ArrayList(); machines.add(new FlyingMachine()); machines.add(new Jet()); machines.add(new Helicopter()); machines.add(new Jet()); new MakeThingsFly().letTheMachinesFly(machines); } } class MakeThingsFly { public void letTheMachinesFly(List flyingMachines) { for (FlyingMachine flyingMachine : flyingMachines) { flyingMachine.fly(); } } } class FlyingMachine { public void fly() { out.println("No implementation"); } } class Jet extends FlyingMachine { @Override public void fly() { out.println("Start, taxi, fly"); } public void bombardment() { out.println("Fire missile"); } } class Helicopter extends FlyingMachine { @Override public void fly() { out.println("Start vertically, hover, fly"); } } 

Explication

a) La classe MakeThingsFly peut fonctionner avec tout ce qui est de type FlyingMachine .

b) La méthode letTheMachinesFly fonctionne également sans aucun changement (!) lorsque vous ajoutez une nouvelle classe, par exemple PropellerPlane :

 public void letTheMachinesFly(List flyingMachines) { for (FlyingMachine flyingMachine : flyingMachines) { flyingMachine.fly(); } } } 

C’est le pouvoir du polymorphism. Vous pouvez implémenter le principe d’ ouverture-fermeture avec lui.

Cela n’ajoute pas grand chose si vous n’utilisez que des jets, l’avantage viendra lorsque vous aurez différentes machines FlyingMachines, par exemple un avion.

Maintenant que vous avez modifié pour inclure plus de classes, l’avantage du polymorphism réside dans le fait que l’abstraction de ce que le type spécifique (et le concept d’entreprise) de l’instance que vous recevez vous permet de voler.

flm.fly() et j.fly() vous donnent la même réponse car le type d’instance est en fait le même, à savoir Jet , donc ils se comportent de la même manière.

Vous pouvez voir la différence lorsque vous:

 FlyingMachines flm = new FlyingMachines(); flm.fly(); Jet j = new Jet(); j.bombarment(); j.fly(); 

Le polymorphism est défini comme la même signature de méthode avec un comportement différent. Comme vous pouvez le voir, FlyingMachines et Jet ont toutes deux la méthode fly() définie, mais la méthode est implémentée différemment, ce qui leur permet de se comporter différemment.

Voir aa

• Polymorphisme

Le polymorphism (à la fois au moment de l’exécution et de la compilation) est nécessaire en Java pour plusieurs raisons.

La substitution de méthode est un polymorphism à l’exécution et la surcharge est le polymorphism du temps de compilation.

Peu d’entre eux sont (certains d’entre eux sont déjà discutés):

1. Collections : supposons que vous disposiez de plusieurs types de machines volantes et que vous souhaitiez les avoir tous dans une même collection. Vous pouvez simplement définir une liste de type FlyingMachines et les append tous.

    List fmList = new ArrayList<>(); fmList.add(new new JetPlaneExtendingFlyingMachine()); fmList.add(new PassengerPlanePlaneExtendingFlyingMachine()); 

   Ce qui précède ne peut être fait que par polymorphism. Sinon, vous devrez maintenir deux listes distinctes.

2. Caste un type à un autre : Déclarez les objects comme:

    FlyingMachine fm1 = new JetPlaneExtendingFlyingMachine(); FlyingMachine fm2 = new PassengerPlanePlaneExtendingFlyingMachine(); fm1 = fm2; //can be done 

3. Surcharge : Pas en relation avec le code que vous avez donné, mais la surcharge est aussi un autre type de polymorphism appelé polymorphism à la compilation .

4. Peut avoir une seule méthode qui accepte le type FlyingMachine gérer tous les types, c’est-à-dire les sous-classes de FlyingMachine. Ne peut être atteint qu’avec le Polymorphism .

Le polymorphism peut aider notre code à supprimer les conditions “if” destinées à produire du code de production, car la suppression de conditions augmentera la lisibilité du code et nous aidera à écrire de meilleurs cas de test unitaire, nous le soaps pour n! (n factoriel) possibilités.

Voyons comment

si vous avez la classe FlyingMachine et qui prend une chaîne dans le constructeur définissant le type de FlyMachine comme ci-dessous

 class FlyingMachine{ private type; public FlyingMachine(Ssortingng type){ this.type = type; } public int getFlyingSpeedInMph { if(type.equals("Jet")) return 600; if(type.equals("AirPlane")) return 300; } } 

Nous pouvons créer deux instances de FlyingMachine comme

  FlyingMachine jet = new FlyingMachine("Jet"); FlyingMachine airPlane = new FlyingMachine("AirPlane"); 

et obtenir les vitesses en utilisant

  jet.fylingSpeedInMph(); airPlane.flyingSpeedInMph(); 

Mais si vous utilisez le polymorphism, vous allez supprimer les conditions if en étendant la classe générique FlyMachine et en remplaçant la méthode getFlyingSpeedInMph comme ci-dessous.

 class interface FlyingMachine { public int abstract getFlyingSpeedInMph; } class Jet extends FlyingMachine { @Override public int getFlyingSpeedInMph(){ return 600; } } class Airplane extends FlyingMachine { @Override public int getFlyingSpeedInMph(){ return 600; } } 

Maintenant, vous pouvez obtenir les vitesses de vol comme ci-dessous

  FlyingMachine jet = new Jet(); jet.flyingSpeed(); FlyingMachine airPlane = new AirPlane(); airPlane.flyingSpeed(); 

La raison pour laquelle le polymorphism est nécessaire dans Java est que le concept est largement utilisé dans l’implémentation de l’inheritance. Il joue un rôle important en permettant aux objects ayant des structures internes différentes de partager la même interface externe.

le polymorphism, comme indiqué clairement par lui-même, un qui a cartographié pour beaucoup.

java est un langage oops, il a donc une implémentation abstraite, surchargée et surchargée

Rappelez-vous que Java n’aurait pas de spécification pour le polymorphism à l’exécution.

il y a aussi quelques exemples de meilleur exemple.

 public abstract class Human { public abstract Ssortingng getGender(); } class Male extends Human { @Override public Ssortingng getGender() { return "male"; } } class Female extends Human { @Override public Ssortingng getGender() { return "female"; } } 

Primordial

redéfinir le comportement de la classe de base. Par exemple, je veux append un compte de vitesse dans la fonctionnalité existante de déplacer dans ma voiture de base.

Surcharge

peut avoir un comportement avec le même nom avec une signature différente. Par exemple, un président en particulier parle fort, mais un autre ne parle que fort.

Le polymorphism ne vous procure des avantages que si vous avez besoin de polymorphism. Il est utilisé lorsqu’une entité de votre projet conceptuel peut être considérée comme la spécialisation d’une autre entité. L’idée principale est “spécialisation”. Un excellent exemple se trouve dans la soi-disant taxonomie, par exemple appliquée aux êtres vivants. Les chiens et les humains sont tous deux des mammifères. Cela signifie que la classe Mammals regroupe toutes les entités ayant certaines propriétés et certains comportements en commun.

De plus, une ElecsortingcCar et une DieselCar sont une spécialisation d’une voiture. Donc, les deux ont un isThereFuel (), car lorsque vous conduisez une voiture, vous vous attendez à savoir s’il ya suffisamment de carburant pour la conduire. Un autre grand concept est “l’attente”.

C’est toujours une bonne idée de dessiner un diagramme ER (entité-relation) du domaine de votre logiciel avant de le démarrer. C’est parce que vous êtes obligé d’imaginer quel type d’entité va être créé et, si vous êtes capable, vous pouvez économiser beaucoup de code pour trouver des comportements communs entre les entités. Mais économiser du code n’est pas le seul avantage d’un bon projet.

Vous pourriez être intéressé à découvrir ce que l’on appelle le “génie logiciel”, c’est un ensemble de techniques et de concepts qui vous permet d’écrire du “code propre” (il y a aussi un excellent livre .

Ajoutons une classe de plus à cela, cela vous aide à comprendre l’utilisation du polymorphism.

 class FlyingMachines { public void fly() { System.out.println("No implementation"); } } class Jet extends FlyingMachines { public void fly() { System.out.println("Start, Jet, Fly"); } } class FighterPlan extends FlyingMachines { public void fly() { System.out.println("Start, Fighter, Fight"); } } public class PolymorphicTest { public static void main(Ssortingng[] args) { FlyingMachines flm = new Jet(); flm.fly(); FlyingMachines flm2 = new FighterPlan(); flm2.fly(); } } 

Sortie:

 Start, Jet, Fly Start, Fighter, Fight 

Ici, pour ce code particulier, il n’ya pas besoin de polymorphism.

Comprenons pourquoi et quand nous avons besoin de polymorphism.

Supposons qu’il existe différents types de machines (voiture, scooter, machine à laver, moteur élecsortingque, etc.) et nous soaps que chaque machine démarre et s’arrête. Mais la logique pour démarrer et arrêter une machine est différente pour chaque machine. Ici, chaque machine aura différentes implémentations à démarrer et à arrêter. Donc, pour fournir différentes implémentations, nous avons besoin de polymorphism.

Ici, nous pouvons avoir une machine de classe de base avec start() et stop() comme méthodes et chaque type de machine peut étendre cette fonctionnalité et @Override ces méthodes.