Java - Polymorphismus

Polymorphismus ist die Fähigkeit eines Objekts, viele Formen anzunehmen. Die häufigste Verwendung von Polymorphismus in OOP tritt auf, wenn eine Elternklassenreferenz verwendet wird, um auf ein Kindklassenobjekt zu verweisen.

Jedes Java-Objekt, das mehr als einen IS-A-Test bestehen kann, wird als polymorph betrachtet. In Java sind alle Java-Objekte polymorph, da jedes Objekt den IS-A-Test für seinen eigenen Typ und für die Klasse Object besteht.

Es ist wichtig zu wissen, dass der Zugriff auf ein Objekt nur über eine Referenzvariable möglich ist. Eine Referenzvariable kann nur einen Typ haben. Einmal deklariert, kann der Typ einer Referenzvariablen nicht mehr geändert werden.

Die Referenzvariable kann anderen Objekten neu zugewiesen werden, sofern sie nicht als final deklariert ist. Der Typ der Referenzvariablen würde die Methoden bestimmen, die sie für das Objekt aufrufen kann.

Eine Referenzvariable kann sich auf jedes Objekt ihres deklarierten Typs oder jeden Untertyp ihres deklarierten Typs beziehen. Eine Referenzvariable kann als Klassen- oder Schnittstellentyp deklariert werden.

Beispiel

Sehen wir uns ein Beispiel an.

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Nun wird die Klasse Deer als polymorph angesehen, da diese mehrfach vererbt wird. Folgendes gilt für die obigen Beispiele −

• Ein Hirsch IST EIN Tier
• Ein Hirsch ist ein Vegetarier
• Ein Hirsch IST EIN Hirsch
• Ein Hirsch ist ein Objekt

Wenn wir die Referenzvariable facts auf eine Deer-Objektreferenz anwenden, sind die folgenden Deklarationen gültig −

Beispiel

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

Alle Referenzvariablen d, a, v, o beziehen sich auf dasselbe Deer-Objekt im Heap.

Virtuelle Methoden

In diesem Abschnitt zeige ich Ihnen, wie das Verhalten von überschriebenen Methoden in Java es Ihnen ermöglicht, beim Entwerfen Ihrer Klassen Vorteile aus der Polymorphie zu ziehen.

Wir haben bereits das Überschreiben von Methoden besprochen, bei dem eine untergeordnete Klasse eine Methode in ihrer übergeordneten Klasse überschreiben kann. Eine überschriebene Methode ist im Wesentlichen in der übergeordneten Klasse verborgen und wird nicht aufgerufen, es sei denn, die untergeordnete Klasse verwendet das Schlüsselwort super innerhalb der überschreibenden Methode.

Beispiel

/* File name : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;

   public Employee(String name, String address, int number) {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }

   public void mailCheck() {
      System.out.println("Mailing a check to " + this.name + " " + this.address);
   }

   public String toString() {
      return name + " " + address + " " + number;
   }

   public String getName() {
      return name;
   }

   public String getAddress() {
      return address;
   }

   public void setAddress(String newAddress) {
      address = newAddress;
   }

   public int getNumber() {
      return number;
   }
}

Nehmen wir nun an, wir erweitern die Employee-Klasse wie folgt −

/* File name : Salary.java */
public class Salary extends Employee {
   private double salary; // Annual salary
   
   public Salary(String name, String address, int number, double salary) {
      super(name, address, number);
      setSalary(salary);
   }
   
   public void mailCheck() {
      System.out.println("Within mailCheck of Salary class ");
      System.out.println("Mailing check to " + getName()
      + " with salary " + salary);
   }
   
   public double getSalary() {
      return salary;
   }
   
   public void setSalary(double newSalary) {
      if(newSalary >= 0.0) {
         salary = newSalary;
      }
   }
   
   public double computePay() {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

Nun studieren Sie das folgende Programm sorgfältig und versuchen, seine Ausgabe zu bestimmen −

/* File name : VirtualDemo.java */
public class VirtualDemo {

   public static void main(String [] args) {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
      System.out.println("Call mailCheck using Salary reference --");   
      s.mailCheck();
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
   }
}

Dies wird das folgende Ergebnis erzeugen −

Ausgabe

Constructing an Employee
Constructing an Employee

Call mailCheck using Salary reference --
Within mailCheck of Salary class
Mailing check to Mohd Mohtashim with salary 3600.0

Call mailCheck using Employee reference--
Within mailCheck of Salary class
Mailing check to John Adams with salary 2400.0

Hier instanziieren wir zwei Salary-Objekte. Einer, der eine Gehaltsreferenz s verwendet , und der andere mit einer Employee-Referenz e .

Beim Aufruf von s.mailCheck() , sieht der Compiler zur Kompilierzeit mailCheck() in der Gehaltsklasse und die JVM ruft zur Laufzeit mailCheck() in der Gehaltsklasse auf.

mailCheck() auf e ist ganz anders, weil e ist eine Mitarbeiterreferenz. Wenn der Compiler e.mailCheck() sieht , sieht der Compiler die Methode mailCheck() in der Employee-Klasse.

Hier hat der Compiler zur Kompilierzeit mailCheck() in Employee verwendet, um diese Anweisung zu validieren. Zur Laufzeit ruft die JVM jedoch mailCheck() in der Gehaltsklasse auf.

Dieses Verhalten wird als Aufruf virtueller Methoden bezeichnet, und diese Methoden werden als virtuelle Methoden bezeichnet. Eine überschriebene Methode wird zur Laufzeit aufgerufen, unabhängig davon, welcher Datentyp die Referenz ist, die zur Kompilierzeit im Quellcode verwendet wurde.