Ihr habt euch mehr Grundlagen-Videos zur Entwicklung mit Java/Android gewünscht. Deshalb gibt es hier das erste wichtige Grundprinzip: Vererbung.

Personen, Schüler und Erwachsene

Was bedeutet eigentlich Vererbung? Wir machen ein Beispiel: Wir haben Schüler und Erwachsene. Schüler gehen in die Schule. Erwachsene haben einen Job. Beide, sowohl Schüler als auch Erwachsene, sind Personen. Wir können also sagen, Person ist der Oberbegriff und Schüler und Erwachsene sind Ableitungen von Personen. Alle drei sind übrigens Models, weil sie in der realen Welt auch existieren, und wir sie im Code sozusagen nachbilden.

Person ist die Super-Klasse. Schüler erbt von Person. Erwachsener erbt auch von Person. Die Begründung: Ein Schüler ist eine Person. Ein Erwachsener ist eine Person.

Klasse Person

Wir schreiben als erstes die Klasse „Person“. Diese bringt eine Eigenschaft mit, die auf alle Personen, also auch auf alle von ihr abgeleiteten Klassen, zutrifft – nämlich der Name. Jede Person, jeder Schüler und jeder Erwachsene hat einen Namen. Außerdem fügen wir der Klasse zwei Methoden hinzu, eine zum Setzen des Namens und eine zum Auslesen des Namens. Die Klasse sieht folglich so aus:

Klasse Schüler (Pupil)

Als nächstes erzeugen wir die Klasse für den Schüler. Die Besonderheit siehst du in der ersten Zeile. Die Klasse „extends“ von der Klasse Person. Das bedeutet, dass die Klasse von Person erbt, also Eigenschaften und Methoden der Person-Klasse mit übernimmt und ihre eigenen Eigenschaften und Methoden hinzufügt.

class Pupil extends Person

Die Schüler-Klasse nennen wir Pupil (englisch für Schüler). Da jeder Schüler zur Schule geht (sollte man hoffen), hat die Klasse in unserem Beispiel eine Eigenschaft für den Namen der Schule. Außerdem fügen wir wieder eine Setter-Methode zum Setzen des Schulnamens, sowie eine Getter-Methode zum Auslesen des Schulnamens hinzu.

Klasse Erwachsener (Adult)

Die Klasse für den Erwachsenen nennen wir Adult (auch wieder englisch). Da zumindest die meisten Erwachsenen einen Job haben, fügen wir der Klasse einen Eigenschaft „job“ hinzu mit entsprechenden Methoden zum Setzen und Auslesen. Und wieder erbt die Klasse von Person, da jeder Erwachsene eine Person ist. Das sieht dann so aus:

Textausgaben

Damit wir nun aus dem Beispiel lernen können, wollen wir ein paar Texte testweise ausgeben. Dazu brauchen wir eine TextView im Layout. Öffne die main_activity.xml Datei. Android Studio hat bereits eine TextView für uns angelegt. Dieser geben wir eine ID, damit wir sie in unserem Hauptprogramm ansprechen können.

Wenn du willst, kannst du außerdem die Schriftgröße vergrößern, wie ich das im Video gemacht habe.

In der MainActivity deklarieren wir die TextView ganz oben.

TextView textView;

In der onCreate-Methode rufen wir dann eine neue Methode auf, die wir initViews nennen. Darin suchen wir die TextView aus dem Layout und weisen sie unserer lokalen Variable von ganz oben zu.

Wie du siehst, rufen wir auch eine Methode namens „test“ auf. Die implementieren wir auch. Darin instanziieren wir jeweils einen Schüler (Pupil) und einen Erwachsenen (Adult), das heißt, wir erstellen jeweils ein neues Objekt dieser beiden Klassen. Außerdem setzen wir gleich ein paar Eigenschaften, und zwar den jeweiligen Namen, die Schule und den Job entsprechend.

Polymorphie

Wir rufen in der test-Methode am Ende „showPerson“ auf und übergeben hier entweder unseren Schüler oder unseren Erwachsenen. Probier später beides aus, um die Unterschiede zu sehen. Damit das überhaupt funktioniert, kommt das Prinzip der Polymorphie ins Spiel. Polymorphie bedeutet, dass sich Objekte unterschiedlich zeigen können. Unser Schüler ist vom Typ Pupil und gleichzeitig auch vom Typ Person. Der Schüler ist also ein Schüler und eine Person gleichzeitig. Er ist „polymorph“.

Wenn wir den Schüler so übergeben, dass wir ihn als Pupil entgegennehmen, hat er neben den Eigenschaften der Person auch die Eigenschaften des Schülers. Er zeigt sich also wie ein Schüler. Wenn wir den Schüler aber so übergeben, dass wir ihn als Person entgegennehmen, hat er nur die Eigenschaften der Person, also nur den Namen. Auf den Schulnamen haben wir dann erstmal keinen Zugriff.

Damit wir nun sowohl einen Schüler als auch einen Erwachsenen an die Methode showPerson übergeben können, müssen wir diese Methode so definieren, dass sie Personen entgegennehmen kann, also Objekt vom Typ „Person“.

protected void showPerson(Person person)

Typ prüfen

Wenn wir in der Methode nun auf das Objekt „person“ zugreifen, sehen wir nur die Methoden „setName“ und „getName“.

Wenn wir nun wieder unterscheiden möchten, ob die Person ein Schüler oder ein Erwachsener ist, können wir das Schlüsselwort „instanceof“ verwenden.

if (person instanceof Pupil) { ... }

Übersetzt: Wenn die Person vom Typ Pupil ist, dann mach etwas.

if (person instanceof Adult) { ... }

Übersetzt: Wenn die Person vom Typ Adult ist, dann mach etwas.

Doch wie kommen wir auf die jeweiligen Eigenschaften von Pupil und Adult? Wir wollen vielleicht den Namen der Schule oder den Job auslesen? Ganz einfach: Wir casten!

Typ umwandeln

Das Umwandeln von einem Typen in einen anderen (kompatiblen) Typen heißt „casten“. Das kommt vom englischen Verb „to cast“ (englisch für „umwandeln“).

Nachdem wir also den Typ entsprechend geprüft haben, können wir jeweils eine neue Variable erzeugen und den Typ umwandeln, um so einen echten Schüler vom Typ Pupil oder einen echten Erwachsenen vom Typ Adult in der Hand zu haben.

Pupil pupil = (Pupil) person;
Adult adult = (Adult) person;

Schauen wir uns den gesamten Code der showPerson-Methode mal an. Der sieht so aus:

Was passiert also? Wir übergeben erstmal eine Person, ganz allgemein. Dann prüfen wir, ob die Person ein Schüler ist. Falls ja, wandeln wir die Person in einen Schüler um. Dazu nutzen wir eine neue Variable namens „pupil“. Dann können wir einen Text ausgeben und dabei auf alle Eigenschaften des Schülers zugreifen, also auf den Namen und den Namen der Schule.

Wenn die Person kein Schüler ist, sondern ein Erwachsener (else-Fall), dann wandeln wir die Person in einen Erwachsenen um. Auch hierfür nutzen wir eine neue Variable. Die nennen wir „adult“. Und wieder machen wir eine Textausgabe. Diesmal greifen wir auf alle Eigenschaften des Erwachsenen zu.

Übrigens: Beim Abrufen des Namens ist es egal, ob wir das mit der Variable „person“ oder mit der Variable „pupil“ bzw. „adult“ machen. Denn alle haben diese Eigenschaft.

Viel Spaß beim Ausprobieren!

Wenn du hierzu Fragen hast, schreib mich einfach an. Nutze dazu die Chatfunktion unten rechts. 🙂