Polymorphie in Java verstehen: Konzepte und praktische Anwendung

Was ist Polymorphie?

Polymorphie ist die Fähigkeit eines Objekts, viele Formen anzunehmen. Die häufigste Verwendung von Polymorphie in OOP tritt auf, wenn eine Elternklassen-Referenz verwendet wird, um auf ein Kindklassen-Objekt zu verweisen.

Jedes Java-Objekt, das mehr als einen IS-A-Test bestehen kann, gilt als polymorph. 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 einzige mögliche Weg, auf ein Objekt zuzugreifen, über eine Referenzvariable ist. Eine Referenzvariable kann nur einen Typ haben. Einmal deklariert, kann der Typ einer Referenzvariablen nicht geändert werden.

Die Referenzvariable kann anderen Objekten zugewiesen werden, sofern sie nicht als final deklariert ist. Der Typ der Referenzvariable bestimmt die Methoden, die sie auf dem Objekt aufrufen kann.

Eine Referenzvariable kann auf jedes Objekt ihres deklarierten Typs oder jeden Subtyp ihres deklarierten Typs verweisen. Eine Referenzvariable kann als Klassen- oder Interface-Typ deklariert werden.

Beispiel

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

Die Deer-Klasse gilt als polymorph, da sie multiple Vererbung aufweist. Folgendes ist für die obigen Beispiele wahr:

• A Deer IS-A Animal
• A Deer IS-A Vegetarian
• A Deer IS-A Deer
• A Deer IS-A Object

Wenden wir die Referenzvariablen-Fakten auf eine Deer-Objektreferenz an, sind die folgenden Deklarationen legal:

Beispiel

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

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

Virtuelle Methoden (Virtual Methods)

In diesem Abschnitt zeige ich Ihnen, wie das Verhalten überschriebener Methoden in Java es Ihnen ermöglicht, Polymorphie beim Design Ihrer Klassen zu nutzen.

Wir haben bereits Methodenüberschreibung besprochen, bei der eine Kindklasse eine Methode in ihrer Elternklasse überschreiben kann. Eine überschriebene Methode ist im Wesentlichen in der Elternklasse versteckt und wird nicht aufgerufen, es sei denn, die Kindklasse verwendet das super-Schlüsselwort innerhalb der überschreibenden Methode.

Beispiel: Employee und Salary

/* Dateiname: 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; }
}

Nun erweitern wir die Employee-Klasse wie folgt:

/* Dateiname: Salary.java */
public class Salary extends Employee {
    private double salary; // Jährliches Gehalt

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

Studieren Sie nun das folgende Programm sorgfältig und versuchen Sie, seine Ausgabe zu bestimmen:

/* Dateiname: 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("\nCall mailCheck using Employee reference--");
        e.mailCheck();
    }
}

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. Eines mit einer Salary-Referenz s, und das andere mit einer Employee-Referenz e.

Beim Aufrufen von s.mailCheck() sieht der Compiler mailCheck() in der Salary-Klasse zur Kompilierzeit, und die JVM ruft mailCheck() in der Salary-Klasse zur Laufzeit auf.

mailCheck() auf e ist ganz anders, weil e eine Employee-Referenz ist. Wenn der Compiler e.mailCheck() sieht, sieht der Compiler die mailCheck()-Methode 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 Salary-Klasse auf.

Dieses Verhalten wird als virtuelle Methodenaufruf bezeichnet, und diese Methoden werden als virtuelle Methoden bezeichnet. Eine überschriebene Methode wird zur Laufzeit aufgerufen, egal welchen Datentyp die Referenz hatte, die im Quellcode zur Kompilierzeit verwendet wurde.