Skip to main content

Polymorphie bringt Vorteile für Java Arrays

Wenn Java Arrays, Schubladen oder Container sein sollen…
Dann wäre der Gebrauch einer solchen Schublade ziemlich einseitig und festgefahren.

Denn in jedes Array passen zwar mehrere Daten – aber immer nur vom gleichen Datentyp.

Immer gleicher Datentyp?
Also eine Schublade nur für Socken, Unterwäsche und der ganze andere Kram passt dann eben nicht hinein.

Um das zu ändern, gibt es das Feature Polymorphie.
Polymorphe Java Arrays sind in der Lage mehrere unterschiedliche Datentypen zu speichern.

Wie das Ganze funktioniert und worauf du dabei unbedingt achten musst – das zeige ich dir jetzt.

Die Vorteile von Java Polymorphie am Beispiel.

Ich finde das Beispiel mit den Schubladen ganz toll.
Also erstell ich zwei Klassen – Socke und Shirts.

Java Polymorphismus Klassen erstellen

Shorts, T-Shirts oder auch Socken dienen einem Zweck – dem Warmhalten der besten Stücke. 🙂
Und deshalb bekommen beide Klassen jeweils noch eine Methode verpasst.
Diese macht nichts weiter als eine Bildschirmausgabe zum Warmhalten zu produzieren.

public class Socke {

	void warmHalten(){
		System.out.println("Die Socke hält deine Füße warm.");
	}
}

Und die Klasse Shirt:

public class Shirt {

	void warmHalten(){
		System.out.println("Das Shirt hält deinen Oberkörper warm.");
	}
}

Dazu noch eine Klasse „SockenShirtSimulator“, in welcher die main-Methode implementiert wird.
Somit kannst du das Programm direkt aus dieser Klasse heraus starten.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		
	}
}

Okay was nun?
Als Nächstes erzeuge ich einige Objekte vom Datentyp „Socke“ und Einige vom Typ „Shirt“.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Socke sockeBlau = new Socke();//Objekt der Klasse Socke
		Socke sockeRot = new Socke();//ein weiteres neues Socke-Objekt
		Socke sockeGelb = new Socke();//drittes Socke-Objekt
		
		Shirt shirtBlau = new Shirt();//Shirt Objekt
		Shirt shirtRot = new Shirt();//zweites Objekt aus der Klasse Shirt
		Shirt shirtGelb = new Shirt();//drittes Shirt
		
	}
}

Soweit ist alles normal.

Was passiert aber, wenn du diese Objekte in einem Array, namens „kleiderSchrank“ oder „schublade“ speichern möchtest?
Das Bild dazu macht es deutlich.

Java Polymorphie Arrays Fehler

Es kommt zur Fehlermeldung.
Natürlich kommt es dazu – Denn in einem Java Array können nur Objekte gespeichert werden, welche dem gleichen Typ des Arrays entsprechen.
Java Polymorphie Arrays erstellen

Und da das Array vom Typ Socke ist, können natürlich nur Socken in diesem Array gespeichert werden.

Also brauchst du im Normalfall ein zweites Array für Shirts.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Socke sockeBlau = new Socke();
		Socke sockeRot = new Socke();
		Socke sockeGelb = new Socke();
		
		Shirt shirtBlau = new Shirt();
		Shirt shirtRot = new Shirt();
		Shirt shirtGelb = new Shirt();
		
		Socke [] schublade = new Socke [3];//Socken-Array
		schublade[0]=sockeBlau;
		schublade[1]=sockeRot;
		schublade[2]=sockeGelb;
		
		Shirt [] schubladeShirt = new Shirt[3];//Shirt-Array
		schubladeShirt[0]=shirtBlau;
		schubladeShirt[1]=shirtRot;
		schubladeShirt[2]=shirtGelb;
			
	}
}

Kein Problem, oder?
Wenn du das ganze Array mit einer Schleife einmal auslesen möchtest, musst du dies immer zweimal machen.
Einmal für die erste Schublade mit den Socken.
Und eine zweite Schleife für die Schublade mit den T-Shirts.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Socke sockeBlau = new Socke();
		Socke sockeRot = new Socke();
		Socke sockeGelb = new Socke();
		
		Shirt shirtBlau = new Shirt();
		Shirt shirtRot = new Shirt();
		Shirt shirtGelb = new Shirt();
		
		Socke [] schublade = new Socke [3];//Socken-Array
		schublade[0]=sockeBlau;
		schublade[1]=sockeRot;
		schublade[2]=sockeGelb;
		
		Shirt [] schubladeShirt = new Shirt[3];//Shirt-Array
		schubladeShirt[0]=shirtBlau;
		schubladeShirt[1]=shirtRot;
		schubladeShirt[2]=shirtGelb;

		//Auslesen Array für Socken
		for (int i = 0; i < schublade.length; i++) {
			schublade[i].warmHalten();
		}
		
		//Auslesen Array für Shirts
		for (int i = 0; i < schubladeShirt.length; i++) {
			schubladeShirt[i].warmHalten();
		}
	}
}

Klicke auf „RUN“.
Und läuft?

Aber mal ganz ehrlich.
Stell dir einmal so eine Schublade vor.
Socken „JA“ – Shirts „NEIN“ – zu blöd, oder?

Die Probleme mal ganz konkret:

  1. Du hast immer doppelten Code und doppelte Schleifen.
  2. Es handelt sich um ein unrealistisches Modell eines Schubfaches, welches „NEIN“ zu Shirts sagt.
  3. Spätere Programmstrukturen müssen immer mehrfach eingefügt, angepasst und gewartet werden.

Also dann – Geht es auch anders und irgendwie besser?

Nutzen wir doch die Vorteile der Java Vererbung bzw. Polymorphie….

Ich sprach im Zusammenhang mit Vererbung immer von der „Vermeidung von doppelten Code“.
Und so ist es natürlich auch hier.

Also lass es uns nutzen. 🙂

Wie könnte die Vererbungslinie in diesem Java Beispiel aussehen?

Am Besten ist es immer die „IST-ES-EIN-FRAGE“ zu stellen.
Somit findest du eine übergeordnete Klasse, welche zu beiden Klassen und deren Objekten passt.

Wie wäre es mit Kleidung?

java-polymorphismus-vererbung

Und jetzt die „IST-ES-EIN“ bzw. „IST-ES-EINE-FRAGE“:

  • Ist die Socke ein Kleidungsstück?
  • Ist das Shirt ein Kleidungsstück?

Zweimal „Ja“ – passt also?

Gehen wir sicherheitshalber noch ein Stückchen weiter:

  • Ist denn auch jede Socke ein Kleidungsstück?
  • Und ist denn auch jedes Shirt ein Kleidungsstück?

Ebenfalls zweimal „ja“.

Somit passt die Vererbungslinie.
Und dies bedeutet für Dich:
Du erstellst also eine neue Klasse, namens Kleidung.

public class Kleidung {
	
	void warmHalten (){
		System.out.println("Diese Kleidung hält dich warm");
	}

}

Und die beiden Java Klassen „Socke“ und „Shirt“ werden zu Kindklassen der Superklasse „Kleidung“.

public class Socke extends Kleidung{

	void warmHalten(){
		System.out.println("Die Socke hält deine Füße warm.");
	}
}
public class Shirt extends Kleidung{

	void warmHalten(){
		System.out.println("Das Shirt hält deinen Oberkörper warm.");
	}
}

Was nun?
Was ist nun besser?

Jetzt kommt der Java Polymorphismus ins Spiel.

Erinnerst du dich?
Polymorphie erlaubt es dir, einen spezielleren Datentyp („Socke“ oder „Shirt“) als allgemeinen Datentyp anzulegen.
Das bedeutet, dass du jede Socke – als „Kleidungsobjekt“ anlegen kannst.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Kleidung sockeBlau = new Socke();//Jede Socke ist auch Kleidung
		Kleidung sockeRot = new Socke();//Jede Socke kann als Kleidungs-Datentyp angelegt werden
		Kleidung sockeGelb = new Socke();
		
		Kleidung shirtBlau = new Shirt();
		Kleidung shirtRot = new Shirt();
		Kleidung shirtGelb = new Shirt();

	}
}

Und natürlich bedeutet dies auch, dass du ein „Kleidungsarray“ anlegen kannst.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Socke sockeBlau = new Socke();
		Socke sockeRot = new Socke();
		Socke sockeGelb = new Socke();

		Shirt shirtBlau = new Shirt();
		Shirt shirtRot = new Shirt();
		Shirt shirtGelb = new Shirt();

		Kleidung schublade[] = new Kleidung[6];//Polymorphes Kleidungsarray kann beide Typen speichern
	}
}

Und in diesem allgemeinen Array kannst du alle spezielleren Datentypen, innerhalb der Vererbungslinie, speichern.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Socke sockeBlau = new Socke();
		Socke sockeRot = new Socke();
		Socke sockeGelb = new Socke();

		Shirt shirtBlau = new Shirt();
		Shirt shirtRot = new Shirt();
		Shirt shirtGelb = new Shirt();

		Kleidung schublade[] = new Kleidung[6];
		schublade[0] = sockeBlau;//Socke in Fach Null
		schublade[1] = sockeRot;
		schublade[2] = sockeGelb;
		schublade[3] = shirtBlau;//Shirt in Fach 3
		schublade[4] = shirtRot;
		schublade[5] = shirtGelb;
	}
}

Und dann benötigst du nur noch eine Programmstruktur um das ganze Array zu lesen.

public class SockenShirtSimulator {

	public static void main(String[] args) {
		Socke sockeBlau = new Socke();
		Socke sockeRot = new Socke();
		Socke sockeGelb = new Socke();

		Shirt shirtBlau = new Shirt();
		Shirt shirtRot = new Shirt();
		Shirt shirtGelb = new Shirt();

		Kleidung schublade[] = new Kleidung[6];
		schublade[0] = sockeBlau;
		schublade[1] = sockeRot;
		schublade[2] = sockeGelb;
		schublade[3] = shirtBlau;
		schublade[4] = shirtRot;
		schublade[5] = shirtGelb;

		for (int i = 0; i < schublade.length; i++) {
			schublade[i].warmHalten();
		}
	}
}

Wenn du jetzt auf „RUN“ klickst – siehst du, dass die speziellen Methoden aus der Shirt- und der „Sockenklasse“ aufgerufen werden.

Somit kannst du auf alle Instanzvariablen oder Instanzmethoden der spezielleren Kindklassen in diesem allgemeinen Array zugreifen.
Nicht schlecht, oder? 🙂

Zusammenfassung:

  • Polymorphie bedeutet, dass du spezielle Objekte anlegen und dafür allgemeinere Datentypen nutzen kannst.
  • Dadurch ist es dir möglich polymorphe Java Arrays anzulegen.
  • Durch das Feature Polymorphie bzw. Polymorphismus kannst du die strenge Typisierung von Arrays aufheben.