Bild Referenz: https://de.wikipedia.org/wiki/Objektrelationale_Abbildung
Intro
Hallo, ich bin's wieder @drifter2! War die letzte Zeit sehr mit dem Hauptaccount und Uni-aufgaben beschäftigt. Hier sind wir aber wieder um mit Java weite zu machen!Der heutige Artikel ist an meinem englischen Artikel "Java Inheritance" basiert. Das bedeutet das wir hauptsächlich über die Vererbung (Inheritance auf Englisch) zwischen Klassen reden werden. Dabei werden wir auch Sachen über Oberklassen und Abstrakte Klassen erwähnen. Natürlich werden wie immer versuchen den Englischen Artikel nun kompletter zu gestallten indem ich zusätzliche Information dazugebe. Also, fangen wir dann mal direkt an!
Vererbung (Inheritance)
Beim vorherigen Artikel haben wir über die "benutzt" und "besteht aus" Beziehungen gesprochen. Die erste ist die so genannte Assoziation, wo keines ein Bestandteil vom anderen ist, weil beim zweiten ein Objekt die anderen enthält. Wenn diese anderen nicht selbständig existieren können handelt es sich um eine Komposition, sonst nennen wir diese Beziehung eine Aggregation.Aber es gibt noch eine weitere Art von Beziehung. Ein Objekt kann mit einem anderen mit einer so genannten "ist ein/e" Beziehung gebunden sein. Das heißt das ein Objekt von einem oder mehreren Objekten Attribute und Methoden erben kann. Dadurch kann eine Kinderklasse eine Vaterklasse erweiteten, indem sie alle Daten und Methoden dieser Klasse erbt und dann neue Attribute und Methoden hinzufügt. Die Attribute und Methoden der Vaterklasse kann man sehr leicht mit dem "@override"-Modifizierer überschreiben, wenn man diese modifizieren will.
Die eigentliche Vererbung wird mit dem Schlüsselwort "extends" implementiert, welches wir bei der Deklarierung einer Klasse wie folgend verwenden können:
public class kinderKlasse extends vaterKlasse{
// Zusätzliche Daten und Methoden der Kinderklasse
}Um auf die Daten und Methoden der Vaterklasse zuzugreifen verwenden wir das Schlüsselwort "super" und denn bereits bekannten "."-Modifizierer. Das ist nur dann nötig wenn wir z.B. eine Methode überschrieben haben. Sonst kann man auch ganz normal ohne "super" klar kommen. Mehr über das ganze wird später noch erwähnt :)
Bevor wir in die so Ober- oder Superklassen eingehen, sollte ich vielleicht noch ein paar Dinge über die Nützlichkeit von der Vererbung andeuten. Durch die Vererbung wird unser Code simpler und kleiner, welches heißt das wir auch Platz speichern. Immer wenn Objekte ähnlich sind und eine gewisse Relation haben, kann man dessen Ähnlichkeiten in einer Oberklasse eintragen und diese Attribute und Methoden dann an die anderen Objekte erben.
z.B. ein Auto und ein LKW sind beides Fahrzeuge, dass bedeutet das diese von einer "Fahrzeug" Klasse Attribute und Methoden wie die folgenden erben können:
- Attribute wie: Automarke, Model, HP, Baujahr, Inhaber usw.
- Methoden wie: geschwindigkeit(), beschleunigung() usw.
Oberklassen
Die Vaterklasse von der wir erben ist natürlich einer Oberklasse die wir auch Superklasse nennen (superclass auf Englisch). Die Oberklasse und unsere Klasse die von ihr erbt, haben natürlich verschiedene Konstruktoren. Das heißt aber nicht das wir den Konstruktor von der Oberklasse nicht verwenden dürfen! Im Gegenteil, es gibt einen kleinen Trick den man verwenden kann um Objekte zu erstellen die von Typen der Oberklasse sind, aber dann trotzdem als Kinderklasse erstellt werden. In Code sieht das wie folgend aus:SuperKlasse ObjektName = new KinderKlasse();Das werdet ihr besser beim Beispiel sehen, wo wir dann sehr leicht ein Feld von verschiedenen Objekten erstellen werden, die alle aber von der selben Oberklasse erben!
Etwas anderes sehr nützliches das man machen kann ist das der Konstruktor der Kinderklasse den Oberklassen Konstruktor verwendet und dann nur noch die zusätzlichen Attribute der Kinderklasse verwalten muss. Das sieht wie folgend aus:
KinderKlasse( // Parameter ){
// Oberklassen Konstruktor verwenden
super( // Parameter für Oberklasse);
// Zusätzliche Attribute verwalten
}Abstrakte Klassen
Viele Oberklassen werden meistens als Abstrakte Klassen definiert da bei denen Funktion nur deklariert werden können in Form von Abstrakte n Methoden-Funktionen, über die wir beim nächsten Artikel reden werden. Eine solche Klasse wird mit dem Schlüsselwort "abstract" definiert. Das sieht wie folgend aus:public abstract class KlassenName{
// Daten
// Methoden (meistens abstrakte Funktionen)
}Eine Klasse die eine solche Abstrakte Klasse erweitert (also von der erbt), muss nicht alle abstrakte Funktionen implementieren. Das ist etwas das man bei Interfaces machen muss, über die wir auch beim nächsten Artikel sprechen werden! Also muss man nur diese Funktionen implementieren (eigentlich überschreiben) die man auch wirklich verwenden will und kann natürlich auch neue erstellen.
Beispielprogramm
Um das ganze das wir heute diskutiert haben besser verstehen zu können, sollten wir noch zuletzt in einer Beispiel eingehen! Sagen wir mal wir wollen ein Programm erstellen welches eine ArrayList aus Formen enthält. Jede Form hat einen Namen und Funktionen mit denen man die Fläche und den Umfang berechnen kann. Zusätzlich werden wir auch die toString() Methode überschreiben um die Objekte leicht ausdrücken zu können. Wir werden 2 Arten von Formen definieren: den Kreis und das Viereck, und 5 zufällige mit zufälligen Werten in die ArrayList einfügen und diese zuletzt noch ausdrücken. Um es noch leichter zu gestallten werden wir auch keine Getter-Setter Methoden verwenden!Form Klasse
public abstract class Form {
String name; // Alle Formen haben einen Namen
// Abstrakte Methoden
public abstract double Umfang();
public abstract double Flaeche();
public String toString() {
return name;
}
}Kreis Klasse
public class Kreis extends Form {
// zusaetliche Informationen
static double pi = 3.14;
double radius;
public Kreis(double radius) {
super(); // Oberklassen Konstruktor
this.radius = radius;
name = "Kreis";
}
public Kreis() {
super(); // Oberklassen Konstruktor
name = "Kreis";
}
public double Umfang() {
return 2 * pi * radius;
}
public double Flaeche() {
return pi * Math.pow(radius, 2);
}
@Override
public String toString() {
return super.toString() + " " + radius;
}
}Viereck Klasse
public class Viereck extends Form{
// zusaetliche Information
double seite;
public Viereck(double seite) {
super(); // constructor of super(or hyper)class
this.seite = seite;
name = "Viereck"; // you can use just name instead of super.name
}
public Viereck() {
super(); // constructor of super(or hyper)class
name = "Viereck"; // you can use just name instead of super.name
}
public double Umfang() {
return 4 * seite;
}
public double Flaeche() {
return Math.pow(seite, 2);
}
@Override
public String toString() {
return super.toString() + " " + seite;
}
}Treiber (Driver) Klasse
import java.util.ArrayList;
import java.util.Random;
public class Driver {
public static void main(String[] args) {
// Liste aus Formen
ArrayList list = new ArrayList<>();
// Random Generator
Random r = new Random();
double random;
// 5 Formen einfuegen
for (int i = 0; i < 5; i++) {
// temporaere Form
Form s;
random = r.nextInt(2); // 0 oder 1
// Kreis erstellen
if (random == 0) {
random = 1 + r.nextDouble() * 5; // [1,6)
s = new Kreis(random);
}
// Viereck erstellen
else {
random = 1 + r.nextDouble() * 5; // [1,6)
s = new Viereck(random);
}
// in Liste einfuegen
list.add(s);
}
// Ausdrucken
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}Ausführungsbeispiel
Die Ausführung könnte z.B. folgendes ausgeben:
Referenzen:
- https://de.wikipedia.org/wiki/Vererbung_(Programmierung)
- https://de.wikibooks.org/wiki/C%2B%2B-Programmierung:_Vererbung
- http://www.scalingbits.com/java/javakurs1/vererbung/java
- http://www.javaseiten.de/ch01s08.html
- https://steemit.com/programming/@drifter1/programming-java-inheritance
Vorherige Artikel
- Von C nach Java -> Ähnlichkeiten mit C, OOP, Ein- und Ausgabe über die Konsole, Array-Feld Objekt, C-like Beispielprogramm
- Klassen und Methoden -> Klassen-Aufbau, Main Klasse, Objekt Klassen und Konstruktoren, Getters und Setters, toString(), Methoden generell, Komplettes Beispielprogramm
- Assoziation, Komposition und ArrayList -> Assoziation, Komposition, ArrayList und ein komplettes Beispielprogramm
Schlusswort
Und das war's dann auch mit dem heutigen Artikel und ich hoffe euch hat dieser Artikel gefallen! Beim nächsten Artikel werden wir über Interfaces und Abstrakte Methoden reden.
Keep on drifting! ;)