Skip to main content

Das Java Vererbung Konzept in einem Rollenspiel

Java ist eine objektorientierte Programmiersprache.

Und das bedeutet nicht nur, dass du Objekte einer Java Klasse erzeugen kannst.
Es bedeutet auch, dass Java Klassen von anderen Klassen erben können.

Wieso das Ganze?
Stell dir einmal ein Rollenspiel vor.

Wie würdest du ein Rollenspiel entwerfen?

  • In einem Rollenspiel gibt es magische Gegenstände.
    Zauberringe, Zauberstäbe, welche bei Benutzung irgendetwas Cooles machen.
  • Es gibt aber auch Gegenstände, wie Schwerter, Äxte und Hämmer.
    Mit denen kannst du gewöhnlich nur zuschlagen.
  • Und natürlich gibt es Helden in so einem Rollenspiel.
    Es gibt die gewöhnlichen Helden, welche kämpfen, herumlaufen und springen können.
  • Und dann gibt es vielleicht noch Superhelden, welche neben dem normalen Zeugs, noch teleportieren, fliegen oder sich verwandeln können.
  • Und na klar brauchst du noch Feinde, Schurken und Gesindel.
    Dies können Menschen, Tiere oder Monster sein.

Ja so ein Rollenspiel ist ziemlich extravagant.
Wenn du jetzt so ein Rollenspiel gedanklich entwerfen müsstest, wie würdest du vorgehen?

Bevor du Objekte machen kannst, brauchst du Java Klassen.

Denn Java Klassen stellen die Gebrauchsanweisung für die Objekte dar.

Du musst also Klassen für alle möglichen Objekte schreiben.
Und in diese Klassen kommen dann Variablen für Stärke, Größe, Level usw.
Außerdem beinhalten diese Klassen auch Methoden.
Und in diesen Methoden vereinbarst du all dies, was die Objekte so können.

Zum Beispiel:

  • Helden können sich bewegen, zuschlagen oder springen.
  • Superhelden können außerdem fliegen.
  • Zauberringe können glänzen, am Finger getragen werden und bei richtiger Anwendung sogar heilen.

Es gibt somit eine Menge zu tun.

Also….
Beginnen wir bei den Helden.
Nehmen wir an, es gibt zehn Helden.
5 Superhelden mit Superkräften und 5 normale Helden ohne Superkräfte.

Wenn du jetzt die Klassen entwerfen würdest, würdest du zwei Klassen erstellen.

  • Die erste Klasse wären die „normalen Helden“.
  • Und die zweite Klasse die Superhelden.

Die Klassen würden Instanzvariablen enthalten.

  • Die Größe des Helden als Integer-Datentyp
  • Der Name des Helden als ein String.
  • Das aktuelle Level des Helden als Integer.
  • Und natürlich folgen Attribute, wie Schlagkraft, Ausdauer, Schnelligkeit und der ganze andere Kram.

Und so könntest du einen Helden erschaffen, welcher männlich ist und folgende Attribute hätte.

  • String geschlecht =“männlich“;
  • int groesse = 180;
  • String personName= „Jack“;
  • int aktLevel= 1;
  • int schlagKraft =22;
  • int ausdauer=15;
  • int schnelligkeit=10;
  • int ruestungLevel = 15;

Und in etwa so könnte der Held dann aussehen.

Java Vererbung Held männlich

Und du würdest einen zweiten Helden erschaffen, mit anderen Attributen.
Diese könnte weiblich sein und Jaqueline heißen.
Java Vererbung weiblich Held

Wichtig ist, dass du aus einer „Helden-Klasse“ so viele Helden produzieren könntest, wie du willst.
Du legst einfach die Instanzvariablen in deiner „Heldenklasse“ an.
Und alle Objekte, welche du aus dieser Klasse anlegst, können ihre persönlichen Eigenschaften erhalten.
Java Vererbung Objekte

Und wie sieht es mit Methoden aus?

Die Instanzmethoden, welche du in den Klassen anlegst, stehen ebenfalls allen Helden zur Verfügung.

Du könntest die Methoden herumlaufen() und zuschlagen() anbieten.

Die Methode zuschlagen, würde die Instanzvariable „schlagKraft“ erwarten.
Und in Abhängigkeit von der Schlagkraft, würde die Methode irgendetwas beim Gegner anrichten.
Und so würde die Methode zuschlagen bei Jack aussehen.

Java Vererbung Methode zuschlagen

Und so bei Jaqueline.
Java Vererbung zuschlagen Methode

Die Methode herumlaufen, würde die Instanzvariablen „schnelligkeit“ und „ausdauer“ erwarten.
Und im Methodenrumpf würden diese verarbeitet werden.
Bei Jack so.
Java Vererbung herumlaufen

Bei Jaqueline so.
Java Vererbung Methode herumlaufen

Die Instanzmethoden stehen somit auch jedem Objekt zur Verfügung, welches aus der Java Klasse für Helden erschaffen wurde.
Java Vererbung Methoden

Halten wir fesst:
Sobald du ein Objekt der Heldenklasse erstellst, bekommt dieses die ganzen Instanzmethoden dazu und kann diese nutzen.

So jetzt haben wir die Helden im Spiel.
Was ist mit den Superhelden?

Du erinnerst dich:
Wir wollten 5 Normalo-Helden erstellen.
Und 5 Superhelden mit Superkräften.

Diese Superhelden sollten genau das Gleiche können, wie die Normalos.
Aber sie sollten noch echt coole Superkräfte haben.

Na dann implementieren wir ein paar Superhelden dazu.

Lass uns die Superhelden erstellen.

Also wie machen wir das?
Lass uns mal zwei Alternativen durchdenken.

Alternative 1
Wir erstellen eine neue Klasse und nennen diese Superhelden.
Und in dieser Klasse kopieren wir den Code der „Normalo-Helden-Klasse“.
Kopieren ist dann Copy und Paste.
Und nachdem wir den ganzen Kram reinkopiert haben, bieten wir noch neue Methoden und Eigenschaften an.
Eben so was, wie das Fliegen, den Röntgenblick usw.

Oder Alternative 2.
Wir erstellen keine neue Klasse.
Stattdessen erweitern wir die Heldenklasse um zusätzliche Methoden und Instanzvariablen.
Und hoffen, dass die Normalos diese niemals nutzen.

Gehen wir doch gedanklich einmal beide Alternativen durch.

Alternative 1:
Wir erstellen eine neue Superhelden-Klasse und kopieren den Helden-Code da hinein.

Java Vererbung Kopieren

Und dann packen wir die fliegen()-Methode, eine Instanzvariable „flugGeschwindigkeit“ und andere coole Sachen rein.
Java Vererbung Methoden hinzufügen

So und irgendwann ist das Spiel fertig.
Du hast die Heldenklasse, die Superheldenklasse und es kann losgehen.

Ein richtig geiles Game.
Bis zu dem Zeitpunkt, an dem du feststellst, dass andere Rollenspiele mehr können.
Da gibt es Methoden zum Waffen-Bauen, zum Heilen, zum Schläge-Ausweichen, zum Ducken usw.

Also was machst du dann?
Du musst diese Methoden implementieren.
Und zwar wieder in beide Klassen.

Also Heldenklasse auf:

  • Waffenbauen-Methode rein.
  • Und Ausweichen-Methode rein.

Dann die Superhelden-Klasse auf und ebenfalls die Waffenbauen-Methode und Ausweichen-Methode rein.

Bis jetzt ist das noch kein Problem.
Du hast nur zwei Klassen.
Aber stell dir doch einmal vor, du bietest verschiedene Heldentypen an.
Eben nicht nur Normalos und Superhelden, sondern Bogenschützen, Berserker, Zauberer, Piraten, Diebe usw.
Und für alle Type eine separate Klasse mit Copy-and-Paste-Code. 🙂
Sobald diese Heldentypen ein neues Feature erhalten sollen, musst du dies in allen Klassen umsetzen.

Die Alternative 1 ist somit nicht ganz optimal.

Also was ist mit Alternative 2?
Du bietest in der Heldenklasse alle Methoden (auch fliegen) und Variablen (auch röntgenblickLevel) an und hoffst darauf, dass nur die Superhelden diese nutzen.
Mal ganz ehrlich – Der Ansatz hört sich doch schon mies an, oder? 🙂

Aber was dann?
Alternative drei heißt Vererbung.

Kümmern wir uns jetzt um die Vererbung der Java Klassen.

Wie kannst du dir dieses ganze Java-Vererbungskonzept vorstellen?

Du erschaffst die Klasse Helden.
Und diese Klasse ist eine sogenannte Superklasse.

Und diese Superklasse hat diverse Unterklassen.
Dies sind dann die Klassen für Superhelden, für Bogenschützen, für Berserker usw.

Aber lass uns bei den Superhelden bleiben.
Was heißt das nun – für die Superhelden.

Die Klasse Superhelden erbt von der Klasse Helden.
Und somit stehen der Superhelden-Klasse alle Methoden und alle Instanzvariablen der Heldenklasse zur Verfügung.
Das ganze geschieht ohne Copy und Paste.
Stattdessen schreibst du in die Klassendefinition das Keyword extends und dann den Namen der Superklasse.

Also: public class SuperHelden extends Helden
Und das war es schon.
Somit besitzt die Unterklasse Superhelden alle Eigenschaften der Heldenklasse.
Cool, oder?

Java Vererbung SuperheldenKlasse

Doch es wird noch besser.
Sobald du die Heldenklasse erweiterst – erweitert sich ganz automatisch die Unterklasse auch.

Das bedeutet für dich.
Wenn du irgendwann feststellst:

  • Die Helden müssen auch ausweichen können.
  • Dann implementierst du eine ausweichen()-Methode in die Heldenklasse.
  • Und dann können alle Normalo-Helden diese Methode nutzen.
  • Aber auch allen Superhelden steht dann diese Funktion zur Verfügung.

Java Vererbung ausweichen

Und was ist mit fliegen(), Röntgenstrahl und den anderen coolen Kram?
Diese Methoden und Instanzvariablen implementierst du nur in der Superhelden-Klasse.

Das tolle ist, dass die Normalo-Helden davon nichts mitbekommen.
Denn Vererbung funktioniert nur in eine Richtung.
Die Heldenklasse ist die Vaterklasse.
Und die Superhelden-Klasse ist die Kindklasse.

Die Vater- oder Oberklasse kann nicht von der Kindklasse erben.
Somit schreibst du alle Methoden, welche Superhelden und Normalo-Helden betreffen in die Vaterklasse (Heldenklasse).

Die Kind- bzw. Unterklasse (Superhelden) erbt das alles.

Und in die Superhelden-Klasse schreibst du den ganzen Kram, welche nur Superhelden können dürfen.

Java Vererbung Rückwärts

Und der Spaß geht noch weiter.
Natürlich kann die Superhelden-Klasse ebenfalls Unterklassen besitzen.
So können manche Superhelden Wände hochklettern.
Wiederum Andere können sich verwandeln.
Java Vererbung Unterklassen

  • Du siehst in der Oberklasse bietest du allgemeine Methoden und Instanzvariablen an.
    All den Kram den alle Helden können.
    Zum Beispiel. herumlaufen()
  • Dann kommt die erste Superheldenklasse.
    Diese erweitert die Heldenklasse um die Methode fliegen().
    Falls du dann ein Superhelden-Objekt erstellst, kann es fliegen.
    Somit können alle Superhelden herumlaufen und fliegen.
    Normalo-Helden, wie Jack und Jaqueline, können weiterhin nur herumlaufen.
  • Es folgen zwei weitere Klassen- Superheldenkletterer und Superheldenverwandler.
    Beide Klassen erweitern die Superhelden.
  • Die Klasse Superheldenkletterer erweitert die Superheldenklasse, um die Methode klettereWaendeHoch().
    Alle Objekte, welche du dann aus der SuperheldenKletterer-Klasse erstellst können dann „Wände hochklettern“, „fliegen“ und herumlaufen.
  • Die zweite Superheldenklasse kann keine Wände hochklettern.
    Dafür steht den Objekten die Methode verwandeln() zur Verfügung.

Wenn du jetzt ein Objekt der „SuperHeldenVerwandler-Klasse“ anlegst, kann dieser:

  • Sich bewegen und all das, was alle Helden aus der Heldenklasse können
  • Fliegen und all das, was alle Superhelden aus der Superhelden-Klasse können.
  • Und sich verwandeln, was speziell nur diese Klasse kann.

Cool, oder? 🙂

Zusammenfassung:

  • Um deinen Code flexibel zu halten, kannst du Java Klassen erweitern.
  • Diese Klassen-Erweiterung machst du mit dem Keyword extends.
  • Das Konzept dahinter nennt sich Vererbung.
  • Alle Superklassen vererben Methoden und Variablen an ihre Unterklassen.
    Somit brauchst du nur den Code in der Superklasse zu ändern und dadurch ändern sich alle Eigenschaften der Unterklassen ebenfalls.
  • Die Unterklassen kannst du dann um spezifische Methoden ergänzen.
  • Die ganze Java Vererbung funktioniert nur in eine Richtung.
    Somit bleiben die Methoden schön in den Unterklassen und stehen den Superklassen nicht zur Verfügung.

Ähnliche Beiträge

Java Konsolenausgaben mit formatierten Zahlen

Java Konsolenausgaben Zahlen

Java Konsolenausgaben erzeugst du mit der System.out.println()-Anweisung. Dies ist relativ einfach. Aber es ist mitunter nicht ganz praktisch. Und zwar immer dann, wenn Zahlen im Spiel sind. Die Zahlen welche dann auf deiner Java Konsole erscheinen, sind unformatiert. Sie haben zu viele Kommastellen. Oder für eine bessere Darstellung benötigst du den Tausenderpunkt. Vielleicht möchtest du […]

Java Duales Zahlensystem – Binäre Zahlen in Java umwandeln

Java Dual System

Das duale Zahlensystem hat viele Bezeichnungen. Oft wird auch es Dualsystem oder Binärsystem genannt. Es besteht aber immer aus 2 Zahlen. Man verwendet oft die Zahlen 0 und 1. Es können aber auch sämtliche anderen Zahlenpaare sein. Zum Beispiel 7 und 175 sind für sich genommen, auch ein normales Zahlenpaar und somit ein Dualsystem. Mit […]

So kannst du Werte aus zwei oder mehreren Java Arrays verrechnen.

Java Arrays verrechnen

Wie kann man Werte aus zwei oder mehreren Java Arrays miteinander verrechnen? Zum Beispiel: Du möchtest alle Werte des ersten Arrays mit allen Werten des zweiten Arrays addieren Oder du möchtest die Summe aus beiden Arrays wissen und erst dann diese miteinander addieren. Was erwartet dich in diesem Beitrag? Zuerst werde ich dir zeigen, wie […]

Den Java Vererbungsbaum nach dem Ist-Es-Prinzip richtig entwerfen

Java Vererbungsbaum

Vererbungsbaum in Java – klingt erstmal komisch. Dennoch wird dies so bezeichnet. Gemeint sind damit – die einzelnen Hierarchiestufen oder Vererbungsebenen – von der Superklasse bis runter zu den Kindklassen. Wie sieht das nun konkret aus? Vererbung bedeutet: Du definierst einen allgemeinen Typen – zB. Möbel Und dann implementierst du eine Unterklasse, welche die Oberklasse […]

So lassen sich aus Java Klassen Instanzen erstellen

Java Klassen Instanzen erstellen

Lass uns jetzt aus den Java Klassen heraus Objekte anlegen. Im Einführungsbeispiel hast du bereits gelernt, wie du: Instanzvariablen bzw. Attribute anlegst Wie du aus einer normalen Java Klasse eine Programmstart Klasse machst In diesem Artikel erfährst du: Was Objekte bzw. Instanzen sind. Wie sich Objekte zusammensetzen. Wo und wie du Instanzen aus Java Klassen […]

Java Vererbung – Die Hierarchien richtig planen

Java Vererbung Hierarchien

Java Vererbung hat nichts mit Biologie zu tun. Die Genetik besagt, dass bestimmte Merkmalsausprägungen von den Eltern auf die Kinder übergehen. Solche Merkmalsausprägungen sind: die Hautfarbe die Haarfarbe die spezifische Größe und weitere körperliche Merkmale. Und in Java – was ist da Vererbung? Lass es uns herausfinden. Was erwartet dich in diesem Beitrag? Zuerst schauen […]

So nutzt du getter und setter Methoden bei der Java Programmierung

Java Keyword private

In diesem Artikel möchte ich dir zeigen, wie du Instanzvariablen innerhalb der Java Klasse schützt. Und den Zugriff nur noch indirekt über getter und setter Methoden anbietest. Stell dir vor. Du hast ein Programm zur Lagerverwaltung geschrieben. Dieses Programm dient Möbelhäusern dazu, ihre Bestände zu verwalten. Und das Programm erwartet vom Nutzer gewisse Eingaben zu […]

So legst du Utility Klassen in Java an

Java Utility Klassen

Utility Java Klassen – was ist das? Man nennt diese auch Hilfsklassen von Java. Diese Utility Klassen sind Java Klassen, welche lediglich Methoden und Konstanten anbieten. Am Beispiel: Die Klasse Math ist so eine klassische Utility Klasse. Wozu braucht man solche Klassen? Diese Klassen sind so etwas wie ein Werkzeugkoffer für jedes Java Programm. Hier […]

So kannst du zweidimensionale Java Arrays anlegen und nutzen

Java Arrays zweidimensional

Eines der bedeutendsten Instrumente in der Mathematik ist das Koordinatensystem. Die gedankliche Grundlage dieses Werkzeuges lieferte der französische Naturwissenschaftler und Philosoph Rene Descartes. Man muss sich einmal verdeutlichen, was dies für die damalige Zeit bedeutete. Bisher wurden mathematische Probleme lediglich durch Berechnungen gelöst. Denke an geometrische Figuren, wie Dreiecke und Vierecke. Der Umfang wurde lediglich […]

Java Exklusives Oder – So nutzt du den Xor Operator

Java exklusives oder

In diesem Beitrag möchte ich dir den Xor Operator von Java vorstellen. Dieser Operator wird auch als ausschließendes oder exklusives Oder bezeichnet. Ein Beispiel: Was wilst du heute zum Mittag essen: Fleisch oder Fisch? Auf diese Frage gibt es nur eine Antwort. Es ist entweder Fisch oder Fleisch. Niemals beides. Das Eine schließt das andere […]

So einfach lassen sich Java Strings umkehren

Java Strings umkehren

Kennst du noch das Lied „ANNA“ von Freundeskreis? Da hieß es: Du bist von hinten, wie von vorne A-N-N-A. Solche Namen oder Wörter, welche von hinten nach vorne gelesen – die gleiche Bedeutung haben, nennt man Palindrome. Anna, Ehe oder Ebbe sind recht kurze Palindrome. Aber auch längere zusammengesetzte Palindrome kennt die deutsche Sprache: Regallager […]