Programmieren in Java - Vererbung zwischen Klassen

in #programmieren6 years ago


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




This post has been voted on by the SteemSTEM curation team and voting trail in collaboration with @curie.

If you appreciate the work we are doing then consider voting both projects for witness by selecting stem.witness and curie!

For additional information please join us on the SteemSTEM discord and to get to know the rest of the community!

Hello! Your post has been resteemed and upvoted by @ilovecoding because we love coding! Keep up good work! Consider upvoting this comment to support the @ilovecoding and increase your future rewards! ^_^ Steem On!

Reply !stop to disable the comment. Thanks!