Polymorphismus in Java-OOPs mit Beispiel:Was ist, dynamisch

Beispiel für Java-Polymorphismus

Änderung der Softwareanforderung

Es gibt eine Änderung in der Anforderungsspezifikation, etwas, das in der Softwarebranche so üblich ist. Sie sollten die Funktionalität des privilegierten Bankkontos mit Überziehungsmöglichkeit hinzufügen.

Zum Hintergrund:Überziehung ist eine Einrichtung, bei der Sie einen Betrag abheben können, der über dem verfügbaren Guthaben auf Ihrem Konto liegt.

Ziehen Sie also die Methode für privilegierte Bedürfnisse zurück, um sie neu zu implementieren. Aber Sie ändern den getesteten Code im Spar- und Girokonto nicht. Dies ist ein Vorteil von OOPS

Schritt 1) So dass beim Aufruf der „abgehobenen“ Methode zum Sparkonto eine Methode aus der übergeordneten Kontoklasse ausgeführt wird

Schritt 2) Beim Aufruf der Methode „Abheben“ für das privilegierte Konto (Dispo) wird jedoch die in der privilegierten Klasse definierte Abhebemethode ausgeführt. Das ist Polymorphismus in OOPs.

Methodenüberschreibung in Java

Das Überschreiben von Methoden ist das Neudefinieren einer Oberklassenmethode in einer Unterklasse.

Regeln für das Überschreiben von Methoden

• Die Methodensignatur, d. h. Methodenname, Parameterliste und Rückgabetyp, müssen genau übereinstimmen.
• Die überschriebene Methode kann die Zugänglichkeit erweitern, aber nicht einschränken, d.h. wenn sie in der Basisklasse privat ist, kann die untergeordnete 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 Überladen und Überschreiben

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 OOPs ist der Mechanismus, mit dem mehrere Methoden mit demselben Namen und derselben Signatur in der Oberklasse und Unterklasse definiert werden können. Der Aufruf einer überschriebenen Methode wird zur Laufzeit 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 Aussage

obj.treatPatient();

Hier gehört die Referenzvariable „obj“ zur übergeordneten Klasse, aber das Objekt, auf das sie zeigt, gehört zur untergeordneten Klasse (wie im folgenden Diagrammbeispiel für Polymorphismus gezeigt).

obj.treatPatient() führt die TreatPatient()-Methode der Unterklasse – Surgeon

Wenn eine Basisklassenreferenz verwendet wird, um eine Methode aufzurufen, wird die aufzurufende Methode von der JVM entschieden, abhängig von dem Objekt, auf das die Referenz zeigt

Obwohl beispielsweise obj eine Referenz auf Doctor ist, ruft es die Methode von Surgeon auf, da es auf ein Surgeon-Objekt zeigt

Dies wird während der Laufzeit entschieden und daher als dynamisch bezeichnet oder Laufzeitpolymorphismus

Unterschied zwischen statischem und dynamischem Polymorphismus

Statischer Polymorphismus in Java ist eine Art Polymorphismus, der die Informationen zum Aufrufen einer Methode zur Kompilierzeit sammelt, während dynamischer Polymorphismus eine Art Polymorphismus ist, der die Informationen zum Aufrufen einer Methode zur Laufzeit sammelt.

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-Schlüsselwort in Java

Was ist, wenn die TreatPatient-Methode in der Surgeon-Klasse die in der Doctor-Klasse definierte Funktionalität ausführen und dann ihre eigene spezifische Funktionalität ausführen möchte?

In diesem Fall das Stichwort 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 folgendermaßen geschrieben werden:

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

Das Schlüsselwort super kann verwendet werden, um auf beliebige Datenmember oder Methoden der Superklasse in der Unterklasse zuzugreifen.

Als nächstes werden wir anhand von Beispielprogrammen etwas über Super-Schlüsselwort, Vererbung und Polymorphismus in Java lernen.

Beispiel:- Um Vererbung, Polymorphismus und Superschlüsselwörter 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(){
            // overriden 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) Entkommentiert die Zeilen 6-9. Speichern, kompilieren und führen Sie den Code aus. Beobachten Sie die Ausgabe.

Schritt 4) Entkommentieren Sie Zeile # 10 . Speichern und kompilieren Sie den Code.

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

Zusammenfassung

• Polymorphismus in der objektorientierten Programmierung tritt auf, wenn es eine oder mehrere Klassen oder Objekte gibt, die durch Vererbung miteinander verbunden sind. Es ist die Fähigkeit eines Objekts, viele Formen anzunehmen.
• Methodenüberschreibung ist die Neudefinition einer Oberklassenmethode in einer Unterklasse.
• Dynamischer Polymorphismus in Java ist der Mechanismus, durch den mehrere Methoden mit demselben Namen und derselben Signatur in der Oberklasse und Unterklasse definiert werden können.
• Statischer Polymorphismus in Java ist eine Art Polymorphismus, der die Informationen zum Aufrufen einer Methode zur Kompilierzeit sammelt, während dynamischer Polymorphismus eine Art Polymorphismus ist, der die Informationen zum Aufrufen einer Methode zur Laufzeit sammelt.
• Das Super-Schlüsselwort kann verwendet werden, um von der Kindklasse auf Methoden der Elternklasse zuzugreifen.