it-swarm.com.de

Warum Polymorphismus verwenden?

Ich habe den folgenden Code, in dem ich eine übergeordnete Klasse und ihr Kind habe. Ich versuche zu ermitteln, wie der Code von der Verwendung von Polymorphismus profitiert. 

class FlyingMachines {
    public void fly() {
        System.out.println("No implementation");
    }
}

class Jet extends FlyingMachines {
    public void fly() {
        System.out.println("Start, Taxi, Fly");
    }

    public void bombardment() {
        System.out.println("Throw Missile");
    }
}

public class PolymorphicTest {
    public static void main(String[] args) {
        FlyingMachines flm = new Jet();
        flm.fly();

        Jet j = new Jet();
        j.bombardment();
        j.fly();
    }
}

Was ist der Vorteil des Polymorphismus, wenn sowohl flm.fly() als auch j.fly() dieselbe Antwort geben?

28
baig772

schauen wir uns zuerst das OO - Design an. Vererbung stellt eine IS-A-Beziehung dar. Im Allgemeinen können wir so etwas wie "Lass unsere FlyingMachines fliegen" sagen. Jede spezifische FlyingMachines (Unterklasse) IS-A FlyingMachines (übergeordnete Klasse), sagen wir Jet, passt zu diesem "lass unsere FlyingMachines fliegen" übernehmen.

also machen wir die Dinge auf abstrakte Weise, orientierte Schnittstellen und Basisklassen, hängen eigentlich nicht von der Detailimplementierung ab, Polymorphismus wird das Richtige tun! 

9
Cruis

In Ihrem Beispiel ist die Verwendung von Polymorphismus nicht besonders hilfreich, da Sie nur eine Unterklasse von FlyingMachine haben. Polymorphismus wird hilfreich, wenn Sie mehrere Arten von FlyingMachine haben. Dann könnten Sie eine Methode haben, die jede Art von FlyingMachine akzeptiert und deren fly()-Methode verwendet. Ein Beispiel könnte testMaxAltitude(FlyingMachine) sein.

Eine weitere Funktion, die nur für Polymorphismus verfügbar ist, ist die Möglichkeit, einen List<FlyingMachine> zu haben, um Jet, Kite oder VerySmallPebbles zu speichern.

Einer der besten Fälle, die man für die Verwendung von Polymorphismus verwenden kann, ist die Möglichkeit, auf Schnittstellen anstatt auf Implementierungen zu verweisen.

Beispielsweise ist es besser, eine Methode zu haben, die als List<FlyingMachine> und nicht als ArrayList<FlyingMachine> zurückgegeben wird. Auf diese Weise kann ich meine Implementierung innerhalb der Methode in eine LinkedList oder eine Stack ändern, ohne Code zu beschädigen, der meine Methode verwendet.

31
Tim Pote

Der Grund für die Verwendung von Polymorphismus besteht darin, dass Sie generische Frameworks erstellen, die eine ganze Reihe verschiedener Objekte mit derselben Schnittstelle erfordern. Wenn Sie einen neuen Objekttyp erstellen, müssen Sie das Framework nicht an den neuen Objekttyp anpassen, solange es den "Regeln" des Objekts folgt.

Ein nützlicheres Beispiel ist in diesem Fall das Erstellen eines Objekttyps "Airport", der verschiedene Arten von FlyingMachines akzeptiert. Der Flughafen definiert eine "AllowPlaneToLand" -Funktion, ähnlich wie:

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

Solange jede Art von FlyingMachine eine geeignete LandPlane-Methode definiert, kann sie selbst richtig landen. Der Flughafen muss nichts über die FlyingMachine wissen, abgesehen davon, dass er zur Landung des Flugzeugs LandPlane auf der FlyingMachine aufrufen muss. Der Flughafen muss sich also nicht mehr ändern und kann weiterhin neue Arten von FlyingMachines akzeptieren, sei es ein Handgleiter, ein UFO, ein Fallschirm usw.

Polymorphismus ist also nützlich für die Frameworks, die um diese Objekte herum aufgebaut sind und generisch auf diese Methoden zugreifen können, ohne dass sie geändert werden müssen.

12
steve8918

Was ist der Vorteil des Polymorphismus, wenn sowohl flm.fly() als auch j.fly() gib mir die gleiche antwort?

Der Vorteil ist das

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

kehrt zurück

"Start, Taxi, Fly"

anstatt

"No implementation"

Das ist Polymorphismus. Sie rufen fly() für ein Objekt vom Typ FlyingMachine auf, und es weiß noch immer, dass es sich tatsächlich um eine Jet handelt, und ruft die entsprechende fly()-Methode anstelle der falschen Methode auf, die "No implementation" ausgibt.

Das heißt, Sie können Methoden schreiben, die mit Objekten des Typs FlyingMachine arbeiten, und sie mit allen Arten von Subtypen wie Jet oder Helicopter versorgen. Diese Methoden werden immer das Richtige tun, dh, die fly()-Methode des entsprechenden Typs wird aufgerufen, anstatt immer dasselbe zu tun was bedeutet, "No implementation". auszugeben

Polymorphismus

Polymorphismus ist in Ihrem Beispiel nicht nützlich.

  • a) Es ist nützlich, wenn Sie verschiedene Objekttypen haben und Klassen schreiben können, die mit all diesen unterschiedlichen Typen arbeiten können, da sie alle der gleichen API entsprechen.

  • b) Es ist auch nützlich, wenn Sie Ihrer Anwendung neue FlyingMachines hinzufügen können, ohne die vorhandene Logik zu ändern.

a) und b) sind zwei Seiten derselben Münze.

Lass mich zeigen wie.

Code-Beispiel

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");
    }
}

Erläuterung

a) Die MakeThingsFly-Klasse kann mit allem arbeiten, was vom Typ FlyingMachine ist.

b) Die Methode letTheMachinesFly funktioniert auch ohne Änderung (!), wenn Sie eine neue Klasse hinzufügen, zum Beispiel PropellerPlane:

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

Das ist die Kraft des Polymorphismus. Sie können das open-closed-Prinzip damit implementieren.

10
Lernkurve

Es ist nicht viel, wenn Sie nur Jets haben. Der Vorteil wird kommen, wenn Sie unterschiedliche FlyingMachines haben, z. Flugzeug 

Nachdem Sie nun mehr Klassen hinzugefügt haben, besteht der Vorteil des Polymorphismus darin, dass die Abstraktion des jeweiligen Typs (und des Geschäftskonzepts) der Instanz, die Sie erhalten, wichtig ist

4
Sebastian Piu

Sowohl flm.fly() als auch j.fly() geben Ihnen die gleiche Antwort, da der Typ der Instanz tatsächlich derselbe ist. Dies ist Jet, daher verhalten sie sich gleich.

Sie können den Unterschied erkennen, wenn Sie:

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

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

Polymorphismus wird als gleiche Methodensignatur mit unterschiedlichem Verhalten definiert. Wie Sie sehen, haben sowohl FlyingMachines als auch Jet die Methode fly() definiert, die Methode ist jedoch unterschiedlich implementiert, was sich als unterschiedlich erweist.

Siehe Aa

3
Pau Kiat Wee

Polymorphismus (sowohl Laufzeit als auch Kompilierzeit) ist in Java aus mehreren Gründen erforderlich.

Überschreiben von Methoden ist ein Laufzeitpolymorphismus und Überladen ist Kompilierzeitpolymorphismus.

Nur wenige von ihnen sind (einige von ihnen sind bereits besprochen):

  1. Collections: Angenommen, Sie haben mehrere Arten von Fluggeräten und möchten, dass sie alle in einer einzigen Sammlung vorhanden sind. Sie können einfach eine Liste des Typs FlyingMachines definieren und alle hinzufügen.

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

    Das obige kann nur durch Polymorphismus erfolgen. Ansonsten müssten Sie zwei getrennte Listen führen.

  2. Einen Typ in einen anderen einordnen []: Deklarieren Sie die Objekte wie folgt:

    FlyingMachine fm1 = new JetPlaneExtendingFlyingMachine();
    FlyingMachine fm2 = new PassengerPlanePlaneExtendingFlyingMachine();
    fm1 = fm2; //can be done
    
  3. Overloading: Bezieht sich nicht auf den von Ihnen angegebenen Code. Überladen ist jedoch auch eine andere Art von Polymorphismus, die als Compile Time Polymorphism bezeichnet wird.

  4. Kann eine einzige Methode haben, die akzeptiert, dass der Typ FlyingMachine alle Typen behandelt, d. H. Die Unterklassen von FlyingMachine. Kann nur mit Polymorphism erreicht werden.

2
Pritam Banerjee

Polymorphismus kann unserem Code auch dabei helfen, die "if" -Bedingungen zu entfernen, die zur Erzeugung von Code auf Produktionsniveau vorgesehen sind, da das Entfernen von Bedingungen die Lesbarkeit des Codes erhöht und uns hilft, bessere Unit-Testfälle zu schreiben. Wenn "n" steht, wissen wir, wenn es n gibt ! (n faktorielle) Möglichkeiten.

Lass uns sehen wie

wenn Sie über die Klasse FlyingMachine verfügen und im Konstruktor eine Zeichenfolge enthält, die den Typ der FlyMachine wie folgt definiert

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;
    }

 }

Wir können zwei Instanzen von FlyingMachine erstellen

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

und erhalte die Geschwindigkeiten mit

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

Wenn Sie jedoch Polymorphismus verwenden, entfernen Sie die if-Bedingungen, indem Sie die generische FlyMachine-Klasse erweitern und die getFlyingSpeedInMph wie folgt überschreiben

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;
    }
}

Jetzt können Sie die Fluggeschwindigkeiten wie folgt berechnen

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

 FlyingMachine airPlane = new AirPlane();
 airPlane.flyingSpeed();
1
murali krish

Polymorphismus bietet nur dann Vorteile, wenn Sie Polymorphismus benötigen. Wird verwendet, wenn eine Entität Ihres konzeptionellen Projekts als Spezialisierung einer anderen Entität betrachtet werden kann. Die Hauptidee ist "Spezialisierung". Ein großartiges Beispiel steht in der sogenannten Taxonomie, die sich beispielsweise auf Lebewesen bezieht. Hunde und Menschen sind beide Säugetiere. Dies bedeutet, dass die Klasse Mammals alle Entitäten gruppiert, die einige Eigenschaften und Verhaltensweisen gemeinsam haben. 

Ein ElectricCar und ein DieselCar sind eine Spezialisierung eines Autos. Beide haben also einen isThereFuel (), denn wenn Sie ein Auto fahren, erwarten Sie zu wissen, ob genug Kraftstoff zum Fahren vorhanden ist. Ein weiteres großartiges Konzept ist "Erwartung". 

Es ist immer eine gute Idee, ein ER-Diagramm (Entity Relationship) der Domäne Ihrer Software zu erstellen, bevor Sie es starten. Das liegt daran, dass Sie sich ein Bild davon machen müssen, welche Art von Entitäten erstellt werden sollen. Wenn Sie genug können, können Sie sich viel Code ersparen, der häufig auftretende Verhaltensweisen zwischen Entitäten findet. Das Speichern von Code ist jedoch nicht der einzige Vorteil eines guten Projekts. 

Vielleicht interessiert es Sie, das sogenannte "Software-Engineering" herauszufinden, es handelt sich um eine Sammlung von Techniken und Konzepten, mit der Sie "sauberen Code" schreiben können (es gibt auch ein großartiges Buch mit dem Namen "Clean code", das von den Programmen allgemein vorgeschlagen wird.) . 

0
Luca Marzi

Für diesen speziellen Code ist hier kein Polymorphismus erforderlich. 

Verstehen wir warum und wann wir Polymorphismus brauchen.

Angenommen, es gibt verschiedene Arten von Maschinen (wie Auto, Roller, Waschmaschine, Elektromotor usw.), und wir wissen, dass jede Maschine startet und stoppt. Die Logik zum Starten und Stoppen einer Maschine ist jedoch für jede Maschine unterschiedlich. Hier hat jede Maschine unterschiedliche Implementierungen zum Starten und Stoppen. Um verschiedene Implementierungen bereitzustellen, benötigen wir Polymorphismus. 

Hier können wir eine Basisklassenmaschine mit start() und stop() als Methoden haben, und jeder Maschinentyp kann diese Funktionalität und @Override diese Methoden erweitern.

0
Jayshree

Fügen wir noch eine weitere Klasse hinzu. Es hilft Ihnen, die Verwendung des Polymorphismus zu verstehen.

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();
    }
}

Ausgabe:

Start, Jet, Fly
Start, Fighter, Fight
0
Vivek Buddhadev

Polymorphismus, wie er für sich klar ist, eine, die für viele kartiert wurde.

Java ist eine Oops-Sprache, die durch Abstraktion, Überladung und Überschreibung implementiert wird

denken Sie daran, dass Java keine Spezifikation für den Laufzeitpolymorphismus hätte.

es hat auch ein gutes Beispiel dafür.

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";
    }
}

Überschreiben

das Verhalten der Basisklasse neu definieren . Zum Beispiel möchte ich eine Geschwindigkeitszählung in die vorhandene Funktionalität von move in meinem Basisfahrzeug einfügen.

Überladung

kann ein gleichnamiges Verhalten mit unterschiedlicher Signatur haben. Zum Beispiel spricht ein bestimmter Präsident klar und laut, aber ein anderer spricht nur laut. 

0
RTA

Der gute Grund für die Notwendigkeit von Polymorphismus in Java ist, dass das Konzept beim Implementieren von Vererbung umfangreich verwendet wird. Es spielt eine wichtige Rolle, wenn Objekte mit unterschiedlichen internen Strukturen dieselbe externe Schnittstelle verwenden dürfen.

0
Harkaran