Programmieren in Java - Vererbung zwischen Klassen

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.

    Natürlich haben dann die zwei Fahrzeugtypen auch ihre eigenen Daten und Methoden, welche nur dort vorkommen.

---

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:

1. https://de.wikipedia.org/wiki/Vererbung_(Programmierung)
2. https://de.wikibooks.org/wiki/C%2B%2B-Programmierung:_Vererbung
3. http://www.scalingbits.com/java/javakurs1/vererbung/java
4. http://www.javaseiten.de/ch01s08.html
5. https://steemit.com/programming/@drifter1/programming-java-inheritance

    Der Artikel ist zu 90% eine Übersetzung von meinen englischen Artikel, aber enthält ein paar zusätzliche Informationen. Die Referenzen haben dabei geholfen die richtigen deutschen Begriffe zu finden und zu verwenden, da ich nicht Deutsch bin und Programmieren in Englisch gelernt habe.

---

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! ;)