Pourquoi utiliser le Polymorphisme?

Dans votre exemple, l'utilisation du polymorphisme n'est pas incroyablement utile, car vous n'avez qu'une sous-classe de FlyingMachine. Polymorphisme devient utile si vous avez plusieurs sortes de FlyingMachine. Ensuite, vous pourriez avoir une méthode qui accepte tout type de FlyingMachine et utilise ses fly() méthode. Un exemple pourrait être testMaxAltitude(FlyingMachine).

Une autre fonctionnalité est disponible uniquement avec le polymorphisme est la capacité d'avoir un List<FlyingMachine> et l'utiliser pour stocker Jet, Kite, ou VerySmallPebbles.

L'un des meilleurs des cas on peut faire pour l'utilisation du polymorphisme est la capacité de se référer à des interfaces plutôt que des implémentations.

Par exemple, il est préférable d'avoir une méthode qui retourne comme List<FlyingMachine> plutôt qu'un ArrayList<FlyingMachine>. De cette façon, je peux changer ma mise en œuvre au sein de la méthode à un LinkedList ou un Stack sans casser le code qui utilise ma méthode.

Quel est l'avantage de polymorphisme lorsque les deux flm.fly() et j.fly()
de me donner la même réponse?

L'avantage est que

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

retourne

"Start, Taxi, Fly"

au lieu de

"No implementation"

C'est le polymorphisme. Vous appelez fly() sur un objet de type FlyingMachine et il ne sait toujours qu'il est en fait un Jet et les appels appropriés fly() plutôt la méthode de la fausse sorties qui "No implementation".

Qui signifie que vous pouvez écrire des méthodes qui fonctionnent avec des objets de type FlyingMachine et de le nourrir avec toutes sortes de sous-types comme Jet ou Helicopter et ceux des méthodes de toujours faire la bonne chose, c'est à dire l'appel de la fly() méthode du type approprié au lieu de faire toujours la même chose, c'est à dire la sortie "No implementation".

Polymorphisme

Polymorphisme n'est pas utile dans votre exemple.

• a) Il devient utile lorsque vous avez différents types d'objets et peut écrire des classes qui peuvent travailler avec tous les différents types parce qu'ils adhèrent à la même API.

• b) Il est également utile lorsque vous pouvez ajouter de nouveaux FlyingMachines à votre application sans modification de la logique existante.

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

Laissez-moi vous 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(String[] args) {
        List<FlyingMachine> machines = new ArrayList<FlyingMachine>();
        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<FlyingMachine> 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 MakeThingsFly de la classe peut travailler avec tout ce qui est du type FlyingMachine.

b) La méthode letTheMachinesFly fonctionne aussi sans tout changer (!) lorsque vous ajoutez une nouvelle classe, par exemple PropellerPlane:

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

C'est le pouvoir de polymorphisme. Vous pouvez mettre en œuvre la ouvert-fermé-principe avec elle.

Les deux flm.fly() et j.fly() vous donner la même réponse en raison de la nature de l'instance est en fait le même, qui est Jet, de sorte qu'ils sont se comportent de la même.

Vous pouvez voir la différence quand vous:

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

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

Polymorphisme est définie comme la même signature de la méthode avec la différence de comportement. Comme vous pouvez le voir, les deux FlyingMachines et Jet avons méthode fly() défini, mais la méthode est implémentée différemment, qui les considèrent comme de se comporter différemment.

Voir
aa

• Le polymorphisme

Polymorphisme peut aussi aider notre code pour supprimer le "si" conditionnel qui vise à produire le niveau de production de code parce que la suppression des conditions feront augmenter la lisibilité du code et nous aide à mieux écrire unité des cas de test, nous savons pour le "n" si des cas, il vient n!(factorielle n) possibilités.

Nous allons voir comment

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

class FlyingMachine{

    private type;

    public FlyingMachine(String 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 d'obtenir les vitesses à l'aide de

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

Mais si vous utiliser le polymorphisme vous allez supprimer les si les conditions en étendant le générique FlyMachine classe et en remplaçant la 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 en tant que ci-dessous

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

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

polymorphisme comme l'indique clairement par lui-même, celui qui mappés pour beaucoup.

java est un oops de la langue afin qu'elle ont de la mise en œuvre en résumé, la surcharge et dominante

souvenir de java n'aurait pas de spécification pour le moment de l'exécution du polymorphisme.

il a quelques meilleur exemple pour elle aussi.

public abstract class Human {

    public abstract String getGender();

}

class Male extends Human
{
    @Override
    public String getGender() {
        return "male";
    }
}

class Female extends Human
{
    @Override
    public String getGender() {
        return "female";
    }
}

Primordial

redéfinir le comportement de la classe de base.
par exemple je veux ajouter un nombre de vitesse int les fonctionnalités existantes de se déplacer dans ma base de Voiture.

Surcharge

peut avoir un comportement du même nom avec une signature différente.
par exemple, un particulier le président parle clairement un fort, mais l'autre ne parle que de la voix.

Nous allons ajouter une classe plus dans le présent, Il vous aident à comprendre l'utilisation du polymorphisme..

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(String[] args) {
        FlyingMachines flm = new Jet();
        flm.fly();

        FlyingMachines flm2 = new FighterPlan();
        flm2.fly();
    }
}

De sortie:

Start, Jet, Fly
Start, Fighter, Fight