it-swarm.com.de

Was ist der Unterschied zwischen dynamischem und statischem Polymorphismus in Java?

Kann jemand ein einfaches Beispiel liefern, das den Unterschied zwischen Dynamic und Static Polymorphism in Java erklärt?

92

Polymorphismus

1. Statische Bindung/Compile-Time-Bindung/Frühes Binden/Überladen von Methoden (in derselben Klasse)

2. Dynamische Bindung/Laufzeitbindung/Späte Bindung/Überschreibende Methode (in verschiedenen Klassen)

Überladenes Beispiel:

class Calculation {  
  void sum(int a,int b){System.out.println(a+b);}  
  void sum(int a,int b,int c){System.out.println(a+b+c);}  

  public static void main(String args[]) {  
    Calculation obj=new Calculation();  
    obj.sum(10,10,10);  // 30
    obj.sum(20,20);     //40 
  }  
}  

überschreibendes Beispiel:

class Animal {    
   public void move(){
      System.out.println("Animals can move");
   }
}

class Dog extends Animal {

   public void move() {
      System.out.println("Dogs can walk and run");
   }
}

public class TestDog {

   public static void main(String args[]) {
      Animal a = new Animal(); // Animal reference and object
      Animal b = new Dog(); // Animal reference but Dog object

      a.move();//output: Animals can move

      b.move();//output:Dogs can walk and run
   }
}
156
KhAn SaAb
  • Die Überladung von Methoden wäre ein Beispiel für statischen Polymorphismus

  • das Überschreiben wäre ein Beispiel für dynamischen Polymorphismus.

    Denn im Überlastfall weiß der Compiler beim Compilieren, welche Methode er mit dem Aufruf verbinden soll. Sie wird jedoch zur Laufzeit für dynamischen Polymorphismus bestimmt

26
user1374

Dynamischer Polymorphismus (zur Laufzeit) ist der zur Laufzeit vorhandene Polymorphismus. Hier kann der Java-Compiler nicht verstehen, welche Methode zur Kompilierzeit aufgerufen wird. Nur die JVM entscheidet, welche Methode zur Laufzeit aufgerufen wird. Methodenüberladung und Methodenüberschreibung mit Instanzmethoden sind Beispiele für dynamischen Polymorphismus.

Zum Beispiel,

  • Stellen Sie sich eine Anwendung vor, die verschiedene Dokumenttypen serialisiert und deserialisiert.

  • Wir können "Document" als Basisklasse und davon verschiedene Dokumenttypen Klassen verwenden. Z.B. XMLDocument, WordDocument usw.

  • Die Dokumentenklasse definiert die Methoden "Serialize ()" und "Deserialize ()" Als virtuelle. Jede abgeleitete Klasse implementiert diese -Methoden auf ihre eigene Weise, basierend auf dem tatsächlichen Inhalt der Dokumente.

  • Wenn unterschiedliche Dokumenttypen Serialisiert/deserialisiert werden müssen, werden die Dokumentobjekte durch Die 'Document'-Klassenreferenz (oder den Zeiger) referenziert und wenn' Serialize () 'oder' Aufgerufene de-serialize () -Methode wird aufgerufen, Entsprechende Versionen der virtuellen Methoden werden aufgerufen.

Statischer (Kompilierzeit) Polymorphismus ist der zur Kompilierzeit gezeigte Polymorphismus. Hier weiß der Java-Compiler, welche Methode aufgerufen wird. Überladen von Methoden und Überschreiben von Methoden mit statischen Methoden; Methoden, die mit privaten oder finalen Methoden überschrieben werden, sind Beispiele für statischen Polymorphismus

Zum Beispiel,

  • Ein Employee-Objekt verfügt möglicherweise über zwei print () -Methoden, von denen eine die Argumente Nr Und eine Präfixzeichenfolge zusammen mit Den Personaldaten anzeigt.

  • Wenn die print () -Methode ohne diese Argumente aufgerufen wird, weiß der Compiler bei Betrachtung der Funktionsargumente, welche Funktion aufgerufen werden soll, und generiert den Objektcode Entsprechend.

Für weitere Informationen lesen Sie bitte "Was ist Polymorphismus" (Google it).

12
rachana

Bindung bezieht sich auf die Verknüpfung zwischen Methodenaufruf und Methodendefinition.

Dieses Bild zeigt deutlich, was verbindlich ist.

 binding

In diesem Bild bindet der Aufruf "a1.methodOne ()" an die entsprechende Definition von methodOne () und der Aufruf "a1.methodTwo ()" bindet an die entsprechende Definition von methodTwo ().

Für jeden Methodenaufruf sollte eine korrekte Methodendefinition vorhanden sein. Dies ist eine Regel in Java. Wenn der Compiler nicht für jeden Methodenaufruf die richtige Methodendefinition sieht, wird ein Fehler ausgegeben.

Kommen Sie nun zur statischen und dynamischen Bindung in Java.

Statische Bindung in Java:

Die statische Bindung ist eine Bindung, die während des Kompilierens auftritt. Es ist wird auch als frühe Bindung bezeichnet, da die Bindung vor einem Programm erfolgt läuft eigentlich

.

Die statische Bindung kann wie im Bild unten gezeigt werden.

 enter image description here

In diesem Bild ist „a1“ eine Referenzvariable vom Typ Klasse A, die auf ein Objekt der Klasse A zeigt. „A2“ ist auch eine Referenzvariable vom Typ Klasse A, jedoch auf ein Objekt der Klasse B.

Während der Kompilierung prüft der Compiler während der Bindung nicht den Objekttyp, auf den eine bestimmte Referenzvariable zeigt. Es prüft lediglich den Typ der Referenzvariablen, über die eine Methode aufgerufen wird, und prüft, ob in diesem Typ eine Methodendefinition für sie vorhanden ist.

Zum Beispiel prüft der Compiler für den Methodenaufruf „a1.method ()“ im obigen Bild, ob für method () eine Methodendefinition in Klasse A vorhanden ist. Weil „a1“ vom Typ A ist. Ebenso wird beim Methodenaufruf „a2.method ()“ geprüft, ob für Methode () Methodendefinition in Klasse A vorhanden ist. Da „a2“ auch vom Typ Klasse A ist. Es wird nicht geprüft, auf welches Objekt "a1" und "a2" zeigen. Diese Art der Bindung wird als statische Bindung bezeichnet.

Dynamische Bindung in Java:

Die dynamische Bindung ist eine Bindung, die zur Laufzeit ausgeführt wird. Es ist auch Late Binding aufgerufen, weil Bindung auftritt, wenn das Programm tatsächlich .__ ist. Laufen.

Während der Laufzeit werden tatsächliche Objekte zum Binden verwendet. Für den Aufruf "a1.method ()" im obigen Bild wird beispielsweise method () des aktuellen Objekts, auf das "a1" zeigt, aufgerufen. Für den Aufruf "a2.method ()" wird Methode () des tatsächlichen Objekts aufgerufen, auf das "a2" zeigt. Diese Art der Bindung wird als dynamische Bindung bezeichnet.

Die dynamische Bindung des obigen Beispiels kann wie folgt demonstriert werden.

 enter image description here

Referenz statisches Binden und dynamisches Binden in Java

10
Elsayed

Polymorphismus: Polymorphismus ist die Fähigkeit eines Objekts, viele Formen anzunehmen. Die häufigste Verwendung von Polymorphismus in OOP tritt auf, wenn eine Referenz einer übergeordneten Klasse verwendet wird, um auf ein untergeordnetes Klassenobjekt zu verweisen.

Dynamische Bindung/Laufzeitpolymorphismus:

Laufzeit Polymorphismus, auch als Methodenüberschreibung bezeichnet. In diesem Mechanismus wird ein Aufruf an eine überschriebene Funktion zur Laufzeit aufgelöst.

public class DynamicBindingTest {

    public static void main(String args[]) {
        Vehicle vehicle = new Car(); //here Type is vehicle but object will be Car
        vehicle.start();       //Car's start called because start() is overridden method
    }
}

class Vehicle {

    public void start() {
        System.out.println("Inside start method of Vehicle");
    }
}

class Car extends Vehicle {

    @Override
    public void start() {
        System.out.println("Inside start method of Car");
    }
}

Ausgabe:

Innenstartmethode des Autos

Static Binding/Kompilierzeit-Polymorphismus:

Welche Methode aufgerufen werden soll, wird nur zur Kompilierzeit festgelegt.

public class StaticBindingTest {

    public static void main(String args[])  {
       Collection c = new HashSet();
       StaticBindingTest et = new StaticBindingTest();
       et.sort(c);

    }

    //overloaded method takes Collection argument
    public Collection sort(Collection c){
        System.out.println("Inside Collection sort method");
        return c;
    }


   //another overloaded method which takes HashSet argument which is sub class
    public Collection sort(HashSet hs){
        System.out.println("Inside HashSet sort method");
        return hs;
    }

}

Ausgabe: Inside Collection sort metho

7
loknath

Methodenüberladung ist ein Beispiel für Kompilierzeit/statischer Polymorphismus, da die Methodenbindung zwischen Methodenaufruf und Methodendefinition zur Kompilierzeit erfolgt und von der Referenz der Klasse abhängt (Referenz wird zur Kompilierzeit erstellt und geht zum Stack).

Überschreiben der Methode ist ein Beispiel für Laufzeit/dynamischen Polymorphismus, da die Methodenbindung zwischen Methodenaufruf und Methodendefinition zur Laufzeit erfolgt und von dem Objekt der Klasse abhängt (Objekt, das zur Laufzeit erstellt wurde und zum Heap geht).

7
Sujith PS

In einfachen Worten : 

Statischer Polymorphismus: Der gleiche Methodenname lautet überladen mit einem anderen Typ oder einer anderen Anzahl von Parametern in derselben Klasse (unterschiedlich Unterschrift). Gezielter Methodenaufruf wird zur Kompilierzeit aufgelöst. 

Dynamischer Polymorphismus: Dieselbe Methode ist überschrieben mit der gleichen Signatur in verschiedenen Klassen. Der Typ des Objekts, für das die Methode aufgerufen wird, ist zur Kompilierzeit nicht bekannt, wird jedoch zur Laufzeit entschieden.

Überladung wird im Allgemeinen nicht als Polymorphismus betrachtet. 

Aus dem Java-Tutorial page :

Unterklassen einer Klasse können ihr eigenes eindeutiges Verhalten definieren und dabei einige Funktionen der übergeordneten Klasse gemeinsam nutzen

6
Ravindra babu

Statischer Polymorphismus: Hier wird während der Kompilierzeit die Entscheidung festgelegt, welche Methode ausgeführt werden soll. Method Overloading könnte ein Beispiel dafür sein.

Dynamischer Polymorphismus: Hier wird während der Laufzeit die Entscheidung getroffen, welche Methode ausgeführt werden soll. Das Überschreiben von Methoden könnte ein Beispiel dafür sein.

3
Kulasangar

Polymorphismus bezieht sich auf die Fähigkeit eines Objekts, sich für denselben Auslöser unterschiedlich zu verhalten.

Statischer Polymorphismus (Kompilierungspolymorphismus)

  • Statischer Polymorphismus entscheidet, welche Methode während der Kompilierung ausgeführt werden soll.
  • Methodenüberladung ist ein Beispiel für statischen Polymorphismus, und es ist erforderlich, dass statischer Polymorphismus auftritt.
  • Statischer Polymorphismus durch statische Bindung.
  • Statischer Polymorphismus findet in derselben Klasse statt.
  • Für statischen Polymorphismus ist keine Objektzuordnung erforderlich.
  • Keine Vererbung bei statischem Polymorphismus.

Dynamischer Polymorphismus (Laufzeitpolymorphismus)

  • Dynamic Polymorphism entscheidet, welche Methode zur Laufzeit ausgeführt wird.
  • Das Überschreiben von Methoden ist ein Beispiel für dynamischen Polymorphismus, und es ist erforderlich, dass dynamischer Polymorphismus auftritt.
  • Dynamischer Polymorphismus durch dynamisches Binden.
  • Dynamischer Polymorphismus tritt zwischen verschiedenen Klassen auf.
  • Es ist erforderlich, wenn ein Unterklassenobjekt für das dynamische Polymorphismus der übergeordneten Klasse Objekt zugewiesen wird.
  • Vererbung für dynamischen Polymorphismus.
2

Method Overloading ist als Static Polymorphism und auch als Compile Time Polymorphism oder Static Binding bekannt, da überladene Methodenaufrufe zur Kompilierzeit aufgelöst werden vom Compiler auf der Grundlage der Argumentliste und der Referenz, auf der die Methode aufgerufen wird.

Und Methodenüberschreibung ist bekannt als dynamischer Polymorphismus oder einfach Polymorphismus oder Laufzeitmethode Dispatch oder dynamisches Binden, da sie überschrieben werden Methodenaufruf wird zur Laufzeit aufgelöst.

Um zu verstehen, warum dies so ist, nehmen wir ein Beispiel der Klassen Mammal und Human

class Mammal {
    public void speak() { System.out.println("ohlllalalalalalaoaoaoa"); }
}

class Human extends Mammal {

    @Override
    public void speak() { System.out.println("Hello"); }

    public void speak(String language) {
        if (language.equals("Hindi")) System.out.println("Namaste");
        else System.out.println("Hello");
    }

}

Ich habe die Ausgabe sowie den Bytecode von in den folgenden Codezeilen eingefügt

Mammal anyMammal = new Mammal();
anyMammal.speak();  // Output - ohlllalalalalalaoaoaoa
// 10: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V

Mammal humanMammal = new Human();
humanMammal.speak(); // Output - Hello
// 23: invokevirtual #4 // Method org/programming/mitra/exercises/OverridingInternalExample$Mammal.speak:()V

Human human = new Human();
human.speak(); // Output - Hello
// 36: invokevirtual #7 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:()V

human.speak("Hindi"); // Output - Namaste
// 42: invokevirtual #9 // Method org/programming/mitra/exercises/OverridingInternalExample$Human.speak:(Ljava/lang/String;)V

Wenn Sie den Code oben betrachten, können Sie sehen, dass die Bytecodes von humanMammal.speak (), human.speak () und human.speak ("Hindi") völlig verschieden sind, da der Compiler anhand der Argumentliste zwischen ihnen unterscheiden kann und Klassenreferenz. Aus diesem Grund ist Method Overloading als Statischer Polymorphismus bekannt.

Der bytecode für anyMammal.speak () und humanMammal.speak () ist jedoch gleich, da laut Compiler beide Methoden für die Mammal-Referenz aufgerufen werden Die Methode auf dem Objekt, und deshalb wird Method Overriding als dynamischer Polymorphismus bezeichnet.

Aus obigem Code und Bytecode ist es also klar, dass die Aufrufmethode während der Kompilierungsphase vom Referenztyp aus betrachtet wird. Zur Ausführungszeit wird jedoch die Methode von dem Objekt aufgerufen, das die Referenz enthält.

Wenn Sie mehr darüber erfahren möchten, lesen Sie mehr unter Wie geht JVM mit Methodenüberladen und internem Überschreiben um .

2
Naresh Joshi

Betrachten Sie den folgenden Code:

public class X
{
    public void methodA() // Base class method
    {
        System.out.println ("hello, I'm methodA of class X");
    }
}

public class Y extends X
{
    public void methodA() // Derived Class method
    {
        System.out.println ("hello, I'm methodA of class Y");
    }
}
public class Z
{
public static void main (String args []) {

    //this takes input from the user during runtime
    System.out.println("Enter x or y");
    Scanner scanner = new Scanner(System.in);
    String value= scanner.nextLine();

    X obj1 = null;
    if(value.equals("x"))
        obj1 = new X(); // Reference and object X
    else if(value.equals("y"))
        obj2 = new Y(); // X reference but Y object
    else
        System.out.println("Invalid param value");

    obj1.methodA();
}
}

Wenn Sie sich den Code ansehen, können Sie nie erkennen, welche Implementierung von methodA () ausgeführt wird, da dies davon abhängt, welchen Wert der Benutzer zur Laufzeit angibt. Es wird also erst zur Laufzeit entschieden, welche Methode aufgerufen wird. Daher Laufzeitpolymorphismus.

1
user2048204

Kompilierzeit-Polymorphismus (statische Bindung/frühe Bindung): Bei statischem Polymorphismus wird, wenn wir eine Methode in unserem Code aufrufen, die Definition dieser Methode tatsächlich nur zur Kompilierzeit aufgelöst.

(oder)

Zum Zeitpunkt der Kompilierung weiß Java, welche Methode aufgerufen werden soll, indem die Methodensignaturen überprüft werden. Dies wird daher als Kompilierungszeit-Polymorphismus oder statisches Binden bezeichnet.

Dynamic Polymorphism (Late Binding/Runtime Polymorphism): Zur Laufzeit wartet Java bis zur Laufzeit, um festzustellen, auf welches Objekt tatsächlich die Referenz verweist. Die Methodenauflösung wurde zur Laufzeit genommen, da wir dies als Laufzeitpolymorphismus bezeichnen.

1
Pavan Reddy

Methodenüberladung ist ein Kompilierzeit-Polymorphismus. Nehmen wir ein Beispiel, um das Konzept zu verstehen.

class Person                                            //person.Java file
{
    public static void main ( String[] args )
    {
      Eat e = new Eat();
       e.eat(noodle);                                //line 6
    }

   void eat (Noodles n)      //Noodles is a object    line 8                     
   {

   }
   void eat ( Pizza p)           //Pizza is a object
  {

  }

}

In diesem Beispiel hat Person eine Essmethode, die darstellt, dass er entweder Pizza oder Nudeln essen kann. Daß die Methode eat beim Kompilieren dieser Person überladen ist, löst der Compiler den Methodenaufruf "e.eat (noodles) [in Zeile 6] mit der in Zeile 8 angegebenen Methodendefinition auf, dh es handelt sich um eine Methode, die Nudeln als Parameter verwendet Der gesamte Prozess wird vom Compiler ausgeführt, also Compile-Time-Polymorphism . Der Prozess des Ersetzens des Methodenaufrufs mit der Methodendefinition wird als Bindung bezeichnet. In diesem Fall wird er vom Compiler ausgeführt, sodass er früh aufgerufen wird Bindung.

0
Manoj Gururaj