Folge 6.3 - Polymorphie

In der Folge 6.2 haben wir die Gemeinsamkeiten der beiden Klassen Rectangle und Circle in eine gemeinsame Oberklasse Figure ausgelagert. Dieses Vorgehen entspricht dem Prinzip der Generalisierung.

Dann haben wir festgestellt, dass die leere paint()-Methode der Oberklasse von den Unterklassen zwar überschrieben werden kann, aber nicht unbedingt überschrieben werden muss. Daher haben wir die paint()-Methode als abstrakte Methode definiert. Abstrakte Methoden bestehen nur aus dem Kopf der Methode und einem abschließenden Semikolon:

 public abstract void paint(Graphics g);

Wenn eine Klasse eine abstrakte Methode enthält, müssen wir auch die gesamte Klasse als abstract kennzeichnen:

abstract class Figure
{
   // Instanzvariablen und Methoden ...
	
	public abstract void paint(Graphics g);
}

In dieser Teilfolge 6.3 wollen wir nun einen wichtigen Fachbegriff der OOP kennenlernen, nämlich den Begriff der Polymorphie. Wenn man in der Fachliteratur oder im Internet recherchiert oder eine KI befragt, erhält man meistens unterschiedliche, manchmal sogar sehr schwammige Definitionen dieses Begriffs. Am Besten macht man sich an einem konkreten Beispiel klar, was mit Polymorphie gemeint ist.

Ein erstes Beispiel für Polymorphie

import java.awt.*;

public class ShowPM
{
    Figure sonne, mond;
    Figure haus, kasten;
    
    public ShowPM()
    {
       sonne = new Circle(360,130,80);
       sonne.setFillColor(Color.YELLOW);
       sonne.setBorderColor(Color.RED);
       
       mond = new Circle(60,300,30);
       mond.setFillColor(new Color(127,127,0));
       mond.setBorderColor(Color.BLUE);    
       
       haus = new Rectangle(100,400,120,60);
       haus.setFillColor(new Color(45,78,92));
       
       kasten = new Rectangle(300,420,60,30);
       kasten.setFillColor(Color.RED);
    }
    
    public void paint(Graphics g)
    {
       sonne.paint(g);
       mond.paint(g);
       haus.paint(g);
       kasten.paint(g);
    }
}

Diese Klasse wird in der paintComponent()-Methode der Klasse Zeichenfenster folgendermaßen aufgerufen:

    protected void paintComponent(Graphics g)
    {
        super.paintComponent(g);
 
        ShowPM scene = new ShowPM();
        scene.paint(g);
    }

In der Klasse ShowPM fällt etwas Interessantes auf. Alle vier Instanzvariablen sonne, mond, haus und kasten besitzen einerseits den Typ Figure, also den Typ der abstrakten Oberklasse.

    Figure sonne, mond;
    Figure haus, kasten;

Andererseits verweisen die Variablen auf Objekte unterschiedlicher Unterklassen: sonne und mond verweisen auf Circle-Objekte, haus und kasten dagegen auf Rectangle-Objekte.

Noch einmal übersichtlich:

• sonne, mond: Datentyp Figure, verweisen auf Circle-Objekte.
• haus, kasten: Datentyp Figure, verweisen auf Rectangle-Objekte.

Eine Variable vom Typ der Oberklasse kann also offensichtlich auf Objekte verschiedener Unterklassen verweisen.

Schauen wir uns nun die Aufrufe der paint()-Methoden an.

    public void paint(Graphics g)
    {
       sonne.paint(g);
       mond.paint(g);
       haus.paint(g);
       kasten.paint(g);
    }

Obwohl alle Variablen den gleichen Typ Figure besitzen, rufen sonne und mond die paint()-Methode der Klasse Circle auf, während haus und kasten die entsprechende Methode der Klasse Rectangle ausführen.

Dieses Verhalten bezeichnet man als Polymorphie. Im weiteren Verlauf dieses Kurses werden wir sehen, dass sich damit Programme deutlich einfacher erweitern und verwalten lassen.