Polymorphismus in Java (Statisch und Dynamisch)

Was ist Polymorphismus in Java?

Polymorphismus in Java Polymorphismus tritt auf, wenn eine oder mehrere Klassen oder Objekte durch Vererbung miteinander verwandt sind. Er beschreibt die Fähigkeit eines Objekts, verschiedene Formen anzunehmen. Vererbung ermöglicht es Benutzern, Attribute und Methoden zu erben, und Polymorphismus nutzt diese Methoden, um unterschiedliche Aufgaben zu erfüllen. Ziel ist die Kommunikation, wobei die Vorgehensweise variieren kann.

Ein Smartphone wird beispielsweise zur Kommunikation genutzt. Die Kommunikationsform kann ein Anruf, eine SMS, eine MMS oder eine E-Mail sein. Das Ziel ist dasselbe – Kommunikation –, aber die Vorgehensweise ist unterschiedlich. Dieses Verhalten ist das Wesen von PolymorphieNun werden wir den Polymorphismus in Java mit Beispielcode, Diagrammen und schrittweisen Erklärungen.

Klicken Sie auf werden auf dieser Seite erläutert wenn das Video nicht zugänglich ist

Warum Polymorphismus verwenden in Java?

Polymorphismus in Java Dieses Muster wird verwendet, weil es Code flexibel, wiederverwendbar und wartungsfreundlicher macht. Eine einzelne Referenzvariable eines übergeordneten Typs kann auf mehrere untergeordnete Objekte verweisen, sodass derselbe Aufruf sich an die jeweilige Unterklasse anpasst. Dieses Muster hält getesteten Code unverändert, während neues Verhalten durch spezialisierte Unterklassen hinzugefügt wird. Genau deshalb basieren Frameworks wie Spring und Jakarta EE darauf.

Java Polymorphismus in OOPs mit Beispiel

Betrachten wir eine Elternklasse namens Konto Die Klasse „Account“ verfügt über Funktionen für Ein- und Auszahlungen und hat zwei Unterklassen. Da die Ein- und Auszahlungsvorgänge für Spar- und Girokonten identisch sind, funktionieren die von der Klasse „Account“ geerbten Methoden.

Java Beispiel für Polymorphismus

Änderung der Softwareanforderungen

Es gibt eine Änderung in der Anforderungsspezifikation, was in der Softwarebranche üblich ist. Die Funktionalität für ein privilegiertes Bankkonto mit Überziehungsmöglichkeit muss hinzugefügt werden. Ein Überziehungskredit ermöglicht es Kunden, einen Betrag abzuheben, der den verfügbaren Kontostand übersteigt. Die Abhebungsmethode für das privilegierte Konto muss neu implementiert werden, während der getestete Code für Spar- und Girokonten unverändert bleibt. Diese Trennung ist der Vorteil von HOPPLA.

Schritt 1) Wenn die Auszahlungsmethode für das Sparkonto aufgerufen wird, wird die in der übergeordneten Kontoklasse definierte Methode ausgeführt.

Schritt 2) Wird die Auszahlungsmethode für das privilegierte Konto (Überziehungskredit) aufgerufen, wird die in der privilegierten Klasse definierte Auszahlungsmethode ausgeführt. Dieser Dispatch ist Polymorphismus in OOPs.

Methodenüberschreibung in Java

Methodenüberschreibung ist der Prozess, eine Methode einer Oberklasse innerhalb einer Unterklasse neu zu definieren. Die Unterklasse behält dabei ihre ursprüngliche Konfiguration bei.tract, sondern stellt eine neue Implementierung bereit, die beim Programmstart ausgewählt wird.

Regeln für das Überschreiben von Methoden

• Die Methodensignatur, also Methodenname, Parameterliste und Rückgabetyp, muss exakt übereinstimmen.
• Die überschriebene Methode kann die Zugänglichkeit erweitern, aber nicht einschränken. Wenn die Methode in der Basisklasse privat ist, kann die abgeleitete Klasse sie öffentlich machen, aber nicht umgekehrt.

Beispiel

class Doctor{
  public void treatPatient(){
  // treatPatient method
  
}
class Surgeon extends Doctor{
  public void treatPatient(){
  // treatPatient method
  }
}
class Run{
  public static void main (String args[]){
    Doctor doctorObj = new Doctor();
    // treatPatient method in class Doctor will be executed
    doctorObj.treatPatient();
   
    Surgeon surgeonObj = new Surgeon();
    // treatPatient method in class Surgeon will be executed
    surgeonObj.treatPatient();
  }
}

Unterschied zwischen Methodenüberladung und Methodenüberschreibung

Methodenüberladung findet innerhalb derselben Klasse mit demselben Methodennamen, aber unterschiedlichen Signaturen statt. Methodenüberschreibung hingegen findet in einer Eltern-Kind-Beziehung statt, wobei die Unterklasse eine in der Oberklasse deklarierte Methode neu definiert.

void sum (int a , int b);
void sum (int a , int b, int c);
void sum (float a, double b);

class X{
  public int sum(){
     // some code
  }
}
class Y extends X{
  public int sum(){
    //overridden method
    //signature is same
 }
}

Was ist dynamischer Polymorphismus?

Dynamischer Polymorphismus in der objektorientierten Programmierung (OOP) ist der Mechanismus, mit dem mehrere Methoden mit demselben Namen und derselben Signatur in der Ober- und Unterklasse definiert werden können. Der Aufruf einer überschriebenen Methode wird zur Laufzeit durch dynamische Bindung innerhalb der JVM aufgelöst.

Beispiel für dynamischen Polymorphismus

Eine Referenzvariable der Oberklasse kann auf ein Objekt der Unterklasse verweisen:

 Doctor obj = new Surgeon();

Betrachten Sie die folgende Aussage:

obj.treatPatient();

Hier die Referenzvariable obj ist von der Elternklasse, aber das Objekt, auf das es zeigt, ist von der Kindklasse, wie im Diagramm der Polymorphie dargestellt.

Der Anruf obj.treatPatient() wird die Methode `treatPatient()` der Unterklasse `Surgeon` ausführen. Wenn eine Basisklassenreferenz zum Aufruf einer Methode verwendet wird, bestimmt die JVM anhand des Objekts, auf das die Referenz verweist, welche Methode aufgerufen wird. Auch wenn obj Es handelt sich um eine Referenz auf Doctor; die Methode wird von Surgeon aufgerufen, da sie auf ein Surgeon-Objekt verweist. Die Entscheidung wird zur Laufzeit getroffen, daher die Bezeichnung. Dynamischer Polymorphismus oder Laufzeitpolymorphismus.

Unterschied zwischen statischem und dynamischem Polymorphismus

Statischer Polymorphismus in Java Bei der klassischen Polymorphie werden die Informationen zum Aufruf einer Methode zur Kompilierzeit gesammelt, während bei der dynamischen Polymorphie die Informationen zum Aufruf einer Methode zur Laufzeit gesammelt werden.

void sum (int a , int b);
void sum (float a, double b);
int sum (int a, int b); //compiler gives error.

//reference of parent pointing to child object
 Doctor obj = new Surgeon();
// method of child called
obj.treatPatient();

Super Keyword in Java

Was passiert, wenn die Methode `treatPatient` in der Klasse `Surgeon` die in der Klasse `Doctor` definierte Funktionalität ausführen und anschließend ihr eigenes spezifisches Verhalten zeigen möchte? In diesem Fall ist das Schlüsselwort … super kann verwendet werden, um von der untergeordneten Klasse aus auf Methoden der übergeordneten Klasse zuzugreifen. Die Methode „treatPatient“ in der Klasse „Surgeon“ könnte wie folgt geschrieben werden:

treatPatient(){
   super.treatPatient();
     //add code specific to Surgeon
}

Das Schlüsselwort `super` ermöglicht den Zugriff auf beliebige Datenelemente oder Methoden der Oberklasse innerhalb der Unterklasse. Im Folgenden werden wir das Schlüsselwort `super` genauer kennenlernen. Erbeund Polymorphismus in Java mit Beispielprogrammen.

Beispiel: Um Vererbung, Polymorphismus und das Schlüsselwort „super“ zu lernen.

Schritt 1) Kopieren Sie den folgenden Code in einen Editor.

public class Test{
     public static void main(String args[]){
        X x= new X();
        Y y = new Y();
        y.m2();
        //x.m1();
        //y.m1();
        //x = y;// parent pointing to object of child
        //x.m1() ;
        //y.a=10;
   }
}
class X{
   private int a;
   int b;
      public void m1(){
       System.out.println("This is method m1 of class X");
     }
}
class Y extends X{
      int c; // new instance variable of class Y
         public void m1(){
            // overridden method
            System.out.println("This is method m1 of class Y");
        }
       public void m2(){
           super.m1();
           System.out.println("This is method m2 of class Y");
      }
}

Schritt 2) Speichern, kompilieren und führen Sie den Code aus. Beobachten Sie die Ausgabe.

Schritt 3) Entfernen Sie die Kommentarzeichen in den Zeilen 6 bis 9. Speichern, kompilieren und führen Sie den Code aus. Beobachten Sie die Ausgabe.

Schritt 4) Zeile 10 auskommentieren. Code speichern und kompilieren.

Schritt 5) Fehler = ? Dies liegt daran, dass die Unterklasse nicht auf private Elemente der Oberklasse zugreifen kann.

Häufig gestellte Fragen