Java-Polymorphie meistern: Konzepte, Beispiele und Best Practices

Java-Polymorphie

Erkunden Sie Java-Polymorphie durch klare Erklärungen und praktische Code-Beispiele und verstehen Sie, wie sie Code-Flexibilität und Wiederverwendbarkeit erhöht.

Polymorphie – ein wesentlicher Pfeiler der objektorientierten Programmierung – bedeutet, dass eine einzelne Entität mehrere Formen annehmen kann.

Das heißt, dieselbe Entität (Methode, Operator oder Objekt) kann je nach Kontext unterschiedliche Operationen ausführen.

Beispiel: Java-Polymorphie

class Polygon { // Methode zum Rendern einer Form public void rendern() { System.out.println("Rendere Polygon..."); } } class Quadrat extends Polygon { // rendert Quadrat public void rendern() { System.out.println("Rendere Quadrat..."); } } class Kreis extends Polygon { // rendert Kreis public void rendern() { System.out.println("Rendere Kreis..."); } } class Haupt { public static void main(String[] args) { // Objekt von Quadrat erstellen Quadrat q1 = new Quadrat(); q1.rendern(); // Objekt von Kreis erstellen Kreis k1 = new Kreis(); k1.rendern(); } }

Ausgabe:

Rendere Quadrat... Rendere Kreis...

Im obigen Beispiel erstellen wir eine Oberklasse: Polygon und zwei Unterklassen: Quadrat und Kreis. Die rendern()-Methode wird von beiden Unterklassen geerbt, aber jede überschreibt sie, um form-spezifische Rendering-Logik bereitzustellen.

Der Kernpunkt ist, dass rendern() sich je nach tatsächlichem Objekttyp unterschiedlich verhält – das ist die Essenz der Polymorphie.

Warum Polymorphie?

Polymorphie ermöglicht Entwicklern, sauberen, konsistenten Code zu schreiben. Anstatt separate Methoden wie quadratRendern() oder kreisRendern() zu definieren, passt sich eine einzelne rendern()-Methode jeder Form an, was Redundanz reduziert und Wartbarkeit verbessert.

Während separate Methoden funktionieren würden, führen sie schnell zu Code-Duplikation und einer fragmentierten API. Polymorphie vereint Verhalten unter einem gemeinsamen Vertrag, sodass jede neue Form durch einfaches Überschreiben von rendern() integriert werden kann.

Hinweis: Die print()-Methode demonstriert ebenfalls Polymorphie – sie kann char, int, String und mehr ausgeben, ohne mehrere Überladungen zu benötigen.

Polymorphie in Java können wir mit folgenden Techniken erreichen:

1. Methodenüberschreibung
2. Methodenüberladung
3. Operatorüberladung

Java Methodenüberschreibung

Wenn eine Unterklasse eine Methode mit derselben Signatur wie eine Methode in ihrer Oberklasse definiert, überschreibt die Unterklassen-Methode die Oberklassen-Methode. Dies ermöglicht, dass derselbe Methodenname je nach Laufzeittyp des Objekts unterschiedliche Operationen ausführt.

Beispiel 1: Polymorphie durch Methodenüberschreibung

class Sprache { public void infoAnzeigen() { System.out.println("Gemeinsame englische Sprache"); } } class Java extends Sprache { @Override public void infoAnzeigen() { System.out.println("Java Programmiersprache"); } } class Haupt { public static void main(String[] args) { // Objekt der Java-Klasse erstellen Java j1 = new Java(); j1.infoAnzeigen(); // Objekt der Sprache-Klasse erstellen Sprache s1 = new Sprache(); s1.infoAnzeigen(); } }

Ausgabe:

Java Programmiersprache Gemeinsame englische Sprache

Hier dient Sprache als Basisklasse und Java als Unterklasse. Die infoAnzeigen()-Methode ist in beiden Klassen definiert, aber jede Implementierung liefert kontextgerechte Informationen.

Die auszuführende Methode wird zur Laufzeit bestimmt, weshalb dieses Muster Laufzeit-Polymorphie genannt wird.

Hinweis: Die aufgerufene Methode wird während der Programmausführung bestimmt. Daher ist Methodenüberschreibung Laufzeit-Polymorphie.

2. Java Methodenüberladung

Methodenüberladung erlaubt einer Klasse, mehrere Methoden mit demselben Namen aber unterschiedlichen Parameterlisten zu haben. Der Compiler löst auf, welche Methode basierend auf den übergebenen Argumenten aufgerufen wird.

void func() { ... } void func(int a) { ... } float func(double a) { ... } float func(int a, float b) { ... }

class Muster { // Methode ohne Parameter public void anzeigen() { for (int i = 0; i < 10; i++) { System.out.print("*"); } } // Methode mit einzelnem Parameter public void anzeigen(char symbol) { for (int i = 0; i < 10; i++) { System.out.print(symbol); } } } class Haupt { public static void main(String[] args) { Muster d1 = new Muster(); // Methode ohne Argument aufrufen d1.anzeigen(); System.out.println("\n"); // Methode mit einzelnem Argument aufrufen d1.anzeigen('#'); } }

********** ##########

int a = 5; int b = 6; // + mit Zahlen int summe = a + b; // Ausgabe = 11

String erster = "Java "; String zweiter = "Programmierung"; // + mit Strings String name = erster + zweiter; // Ausgabe = Java Programmierung

class Programmiersprache { public void anzeigen() { System.out.println("Ich bin eine Programmiersprache."); } } class Java extends Programmiersprache { @Override public void anzeigen() { System.out.println("Ich bin eine objektorientierte Programmiersprache."); } } class Haupt { public static void main(String[] args) { // Objektvariable deklarieren Programmiersprache ps; // Objekt der Programmiersprache erstellen ps = new Programmiersprache(); ps.anzeigen(); // Objekt der Java-Klasse erstellen ps = new Java(); ps.anzeigen(); } }

Ich bin eine Programmiersprache. Ich bin eine objektorientierte Programmiersprache.