Zur Vererbung: Wann und wie?

[Wuast]

Hallöchen,
ich möchte gerne einen Input aus einer Klasse1 in einer anderen Klasse2 verwenden. Wenn ich das richtig verstanden habe, benötige ich dafür die Vererbung.
Ist das richtig?

Wie sieht es hier zum Bleifstift aus:

public class Klasse1 {
 
    String eingabe 1;
    Int eingabe 2;
 
    eingabe1 = new java.util.Scanner(System.in).nextLine();
    eingabe2 = new java.util.Scanner(System.in).nextInt();

public class Klasse2 extends Klasse1 {        //Klasse2 erbt von Klasse1
 
    System.out.println("Ein Mensch sagt: " + eingabe1)
 
        int wert = eingabe2*(random);
 
}

Was muss ich tun, damit ich in Klasse 2 die eingabe1 und eingabe2 der Klasse 1 aufgreifen kann? Oder muss ich bei Vererbungen IMMER noch eine Superklasse erstellen, die dann quasi nur noch als Erblasser fungiert?

Ist Klasse1 somit die Superklasse für Klasse2 und kann ich zu Klasse1 auch noch in der Main eine Instanz aufrufen?
Danke und mfG


Edit: Wenn ich eine spielerx in Klasse2 habe, könnte es doch funktionieren mit:

public class Klasse2 extends Klasse1{

public Point [] spielerx (int spielerAnzahl, int eingabe1, int eingabe2)        // Koordinaten, durch eine Konsoleneingabe festgelegt
                                                                                                                     // vllt. bekannt aus dem Math.random-Thread

   for (int i = 1; i <=spielerAnzahl; i++) {
   Point[i] = new Point ( ((int) (Math.random() * eingabe1)), ((int) (Math.random() * eingabe2)) );
   }

}

Sieht hier jemand einen Fehler der mir nicht auffällt? Erhält die Methode spielerx die int spielerAnzahl, int eingabe1, int eingabe2 von der klasse 1 (angenommen, klasse 1 hätte entsprechende Werte, die vererbt werden könnten) oder muss ich die Parameter noch beim aufrufen der Methode übergeben? In diesem Fall wäre ja nichts vererbt worden

Bin da etwas verwirrt.

Gibt es noch Tipps und Tricks zur Vererbung, die man im Standard-YT-Video nicht vermittelt bekommt?

Danke!!

 

[mihe7]

ich möchte gerne einen Input aus einer Klasse1 in einer anderen Klasse2 verwenden. Wenn ich das richtig verstanden habe, benötige ich dafür die Vererbung.
Ist das richtig?

Nein, das ist völlig falsch. Mit Vererbung drückt man ist-ein(e)-Beziehungen aus. Um Daten zwischen Objekten auszutauschen, stehen Methoden zur Verfügung. Dabei muss ein Objekt nur das andere kennen - entweder als Attribut oder Parameter.

 

[Wuast]

Nein, das ist völlig falsch. Mit Vererbung drückt man ist-ein(e)-Beziehungen aus. Um Daten zwischen Objekten auszutauschen, stehen Methoden zur Verfügung. Dabei muss ein Objekt nur das andere kennen - entweder als Attribut oder Parameter.

Mist...

 

[Wuast]

Mit Vererbung drückt man ist-ein(e)-Beziehungen aus.

Kannst du ein Bsp. in Bezug auf meine obigen Code-Schnipsel geben?

Und wie müsste ich denn die entsprechenden Werte übergeben?
Soweit ich das bisher verstanden habe läuft das mit den ()

Klasse2.spielerx(parameter1, parameter2, parameter3)

Aber wenn ich jetzt die methode spielerx der Klasse2 in der Main aufrufen möchte, die ParameterDaten aber in der Klasse1 generiert habe... wie soll das funktionieren? Muss ich dann die Klasse1.Methodexyz in der Main aufrufen, entsprechende Variablen speichern und die dann an die Klasse2 schicken? Ich kann mir nicht vorstellen, dass DAS die beste Möglichkeit ist

 

[Blender3D]

Hallöchen,
ich möchte gerne einen Input aus einer Klasse1 in einer anderen Klasse2 verwenden. Wenn ich das richtig verstanden habe, benötige ich dafür die Vererbung.
Ist das richtig?

Nein stimmt nicht. Der Code ist so nicht zu gebrauchen!
Ein Beispiel wie du das angehen könntest. Vererbung brauchst du hier noch nicht.
[CODE lang="java" title="TestSpieler"]import java.awt.Point;
import java.util.Random;
import java.util.Scanner;

public class TestSpieler {
static final Scanner input = new Scanner(System.in);
static final Random rnd = new Random(System.currentTimeMillis());

public static void main(String[] args) {
Point pos = inputIntPair("Spielfeld Koordinaten bitte eingeben x,y");
Point dim = inputIntPair("Spielfeld Dimension eingeben w,h");
PlayField field = new PlayField(pos.x, pos.y, dim.x, dim.y);
System.out.println("Das Spielfeld > " + field);
Point p = getRandomPosWithin(field);
System.out.println("Der Zufallspunkt " + p + " liegt im Spielfeld!");
}

public static int getRndIntWithin(int min, int max) {
min = Math.abs(min);
max = Math.abs(max);
if (min > max) {
int tmp = min;
min = max;
max = tmp;
}
return min + rnd.nextInt(max - min + 1);
}

public static Point getRandomPosWithin(PlayField field) {
int x = getRndIntWithin(field.x, field.x + field.width);
int y = getRndIntWithin(field.y, field.y + field.height);
return new Point(x, y);
}

public static Point inputIntPair(String label) {
boolean ok = false;
int x = 0;
int y = 0;
do {
System.out.print(label + " >");
String txt = input.next();
if (!txt.contains(","))
System.err.println("Bitte 2 Zahlen x,y eingeben!");
else {
String pos[] = txt.split(",");
try {
x = Integer.parseInt(pos[0]);
y = Integer.parseInt(pos[1]);
ok = true;
} catch (NumberFormatException e) {
System.err.println("Bitte nur ganze Zahlen eingeben!");
}
}
} while (!ok);
return new Point(x, y);
}

}[/CODE]
[CODE lang="java" title="PlayField"]public class PlayField {
public final int x; // playfield's x position
public final int y; // playfield's y position
public final int width; // playfield's width
public final int height;// playfield's height

public PlayField(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}

@Override
public String toString() {
return String.format("[%d,%d,w=%d,h=%d]", x, y, width, height);
}

}[/CODE]

 

[mihe7]

Kannst du ein Bsp. in Bezug auf meine obigen Code-Schnipsel geben?

Hat sich mit dem Kommentar von @Blender3D erledigt

 

[Wuast]

Nein stimmt nicht. Der Code ist so nicht zu gebrauchen!
Ein Beispiel wie du das angehen könntest. Vererbung brauchst du hier noch nicht.
[CODE lang="java" title="TestSpieler"]import java.awt.Point;
import java.util.Random;
import java.util.Scanner;

public class TestSpieler {
static final Scanner input = new Scanner(System.in);
static final Random rnd = new Random(System.currentTimeMillis());

public static void main(String[] args) {
Point pos = inputIntPair("Spielfeld Koordinaten bitte eingeben x,y");
Point dim = inputIntPair("Spielfeld Dimension eingeben w,h");
PlayField field = new PlayField(pos.x, pos.y, dim.x, dim.y);
System.out.println("Das Spielfeld > " + field);
Point p = getRandomPosWithin(field);
System.out.println("Der Zufallspunkt " + p + " liegt im Spielfeld!");
}

public static int getRndIntWithin(int min, int max) {
min = Math.abs(min);
max = Math.abs(max);
if (min > max) {
int tmp = min;
min = max;
max = tmp;
}
return min + rnd.nextInt(max - min + 1);
}

public static Point getRandomPosWithin(PlayField field) {
int x = getRndIntWithin(field.x, field.x + field.width);
int y = getRndIntWithin(field.y, field.y + field.height);
return new Point(x, y);
}

public static Point inputIntPair(String label) {
boolean ok = false;
int x = 0;
int y = 0;
do {
System.out.print(label + " >");
String txt = input.next();
if (!txt.contains(","))
System.err.println("Bitte 2 Zahlen x,y eingeben!");
else {
String pos[] = txt.split(",");
try {
x = Integer.parseInt(pos[0]);
y = Integer.parseInt(pos[1]);
ok = true;
} catch (NumberFormatException e) {
System.err.println("Bitte nur ganze Zahlen eingeben!");
}
}
} while (!ok);
return new Point(x, y);
}

}[/CODE]
[CODE lang="java" title="PlayField"]public class PlayField {
public final int x; // playfield's x position
public final int y; // playfield's y position
public final int width; // playfield's width
public final int height;// playfield's height

public PlayField(int x, int y, int width, int height) {
this.x = x;
this.y = y;
this.width = width;
this.height = height;
}

@Override
public String toString() {
return String.format("[%d,%d,w=%d,h=%d]", x, y, width, height);
}

}[/CODE]

Puh das ist für "mal eben nachfragen" viel ich schau mal ob ich das auf meine Situation übertragen bekomme und bin ansonsten so frech mich nochmal zu melden!

Danke euch beiden!

 

[Jw456]

Zu deinen ersten Beispiel Klasse1 und 2

Du erbst in klasse2 von 1
In der Klasse 2 ist Klasse eins die Superklasse. Mit dieser Hilfs Variablen kannst du auf Elemente der gerebten Klasse zugreifen.
Die Superklasse ist sozusagen ein Zeiger auf das Objekt der gerebten Klasse.
Also mit super.eingabe1 solltest du auf die variable zugreifen können.

 

[temi]

Ob und wie der Zugriff auf die geerbten Eigenschaften oder Methoden möglich ist, hängt von der Sichtbarkeit ab.

Private Elemente sind nur in der eigenen Klasse zugreifbar. Die Kindklasse kann ggf. über Getter zugreifen.
Protected Elemente sind auch aus der Kindklasse zugreifbar.
Package private Elemente sind zugreifbar, wenn die Kindklasse im gleichen Package ist.

Was man sinnvoll einsetzt, hängt von der Anwendung ab. Generell gilt immer: Soviel verbergen wie möglich! Nur sichtbar machen was nötig!

public class Foo {

    private int privateValue = 1;
    protected int protectedValue = 2;
    int packagePrivateValue = 3; // ohne besondere Angabe der Sichtbarkeit

    public int getPrivateValue() {
        return privateValue;
    }
}

public class FooBar extends Foo {

    public void doSomething() {

        int value1 = getPrivateValue(); // get the private value via public getter
        int value2 = protectedValue; // get the protected value
        int value3 = packagePrivateValue; // get the package private value, when in same package

        System.out.println(value1);
        System.out.println(value2);
        System.out.println(value3);
    }
}

 

[mrBrown]

Also mit super.eingabe1 solltest du auf die variable zugreifen können.

BTW: super braucht man nur, wenn Dinge aus der Oberklasse verdeckt oder überschrien sind.

 

[Wuast]

Zu deinen ersten Beispiel Klasse1 und 2

Du erbst in klasse2 von 1
In der Klasse 2 ist Klasse eins die Superklasse. Mit dieser Hilfs Variablen kannst du auf Elemente der gerebten Klasse zugreifen.
Die Superklasse ist sozusagen ein Zeiger auf das Objekt der gerebten Klasse.
Also mit super.eingabe1 solltest du auf die variable zugreifen können.

Danke für den Beitrag.

Warum hieß es denn vorher, dass mein Code nicht zu gebrauchen sei wenn ich doch recht knapp dran vorbei bin?!

 

[thecain]

Mit Vererbung drückt man ist-ein(e)-Beziehungen aus. Um Daten zwischen Objekten auszutauschen, stehen Methoden zur Verfügung. Dabei muss ein Objekt nur das andere kennen - entweder als Attribut oder Parameter.

Deswegen. Nur weil etwas "geht" ist es nicht automatisch richtig.

 

[Wuast]

Hm also jetzt wirds verwirrend... für mich Anfänger zumindest. Es geht aber es ist falsch?? 😆🤪

Ich wollte doch nur den für mich einfachsten Weg, eine Variable "eingabe1" aus Klasse 1 (die NICHT die main enthält) in einer Methode in Klasse2 nutzen zu können... :/

Also als Beispiel

public class Klasse1 {
   
    int eingabe1 = new java.util.Scanner(System.in).nextInt();
   
    public int eingabe1; //sonst Fehlermeldung ala "create field"
}

public class Klasse2 extends Klasse1 {
   
    int eingabe1 = super.eingabe1;
   
    int result = eingabe1*(Math.random());
}

das geht aber ist falsch?

 

[mrBrown]

Hm also jetzt wirds verwirrend... für mich Anfänger zumindest. Es geht aber es ist falsch?? 😆🤪

Um einen Karton in deine Garage zu bringen, kannst du das durchaus zur Post bringen, an dich selbst schicken, und das per Abstellgenehmigung in deiner Garage abstellen lassen – oder aber du stellst es einfach direkt in deine Garage. Pakete per Post verschicken ist durchaus manchmal richtig, aber dabei kompletter Unsinn.

Genauso ist das hier mit Vererbung: die geht ganz grundsätzlich und ist für manche (eher sehr wenige) Fälle das richtige, hier ist sie aber falsch

 

[mihe7]

ch wollte doch nur den für mich einfachsten Weg, eine Variable "eingabe1" aus Klasse 1 (die NICHT die main enthält) in einer Methode in Klasse2 nutzen zu können... :/

class Klasse1 {
    private int wert;

    public int getWert() { return wert; }
}

class Klasse2 {
    public void zeigeWert(Klasse1 objekt) {
        System.out.println(objekt.getWert());
    }
}

 

[Wuast]

Um einen Karton in deine Garage zu bringen, kannst du das durchaus zur Post bringen, an dich selbst schicken, und das per Abstellgenehmigung in deiner Garage abstellen lassen

Hä? Mach ich immer so

class Klasse1 {
    private int wert;

    public int getWert() { return wert; }
}

class Klasse2 {
    public void zeigeWert(Klasse1 objekt) {
        System.out.println(objekt.getWert());
    }
}

Danke!

 

[mihe7]

Hä? Mach ich immer so

Ja, manche zeugen auch Kinder, um die Fähigkeit, den Müll rauszubringen, vererben zu können

 

[Blender3D]

Hm also jetzt wirds verwirrend... für mich Anfänger zumindest.

Hier ein Beispiel für Vererbung. Die Klasse Sprite realisiert bewegte Grafikobjekte für z.B. ein Spiel.
Die Klasse Ducky erbt von Sprite und fügt zur Funktionalität von Sprite die Möglichkeit zu Springen hinzu.
https://www.java-forum.org/thema/spielerbewegungen-realisieren.191048/#post-1246008

 

[Wuast]

Hier ein Beispiel für Vererbung. Die Klasse Sprite realisiert bewegte Grafikobjekte für z.B. ein Spiel.
Die Klasse Ducky erbt von Sprite und fügt zur Funktionalität von Sprite die Möglichkeit zu Springen hinzu.
https://www.java-forum.org/thema/spielerbewegungen-realisieren.191048/#post-1246008

Danke. Muss ich mir nochmal reintu, wenn ich mit meiner Aufgabe hier durch bin und etwas entspannen kann. Ich glaub (bzw ich weiß), ich muss das ein oder andere nochmal nachholen. xD
Vererbung war für mich ganz neu. Das, was du schreibst und verlinkt hast, passt eigentlich gut zu dem, was ich in besagtem YT-Video gelernt habe (nur, dass dort eben eine neue Superklasse erstellt wurde).

Aber Quintessenz zur Vererbung - bezogen auf mein Beispiel - hat mrBrown ja eindrucksvoll dargestellt. Geht zwar auch, ist aber albern

 

[Jw456]

Um einen Karton in deine Garage zu bringen, kannst du das durchaus zur Post bringen, an dich selbst schicken, und das per Abstellgenehmigung in deiner Garage abstellen lassen – oder aber du stellst es einfach direkt in deine Garage. Pakete per Post verschicken ist durchaus manchmal richtig, aber dabei kompletter Unsinn.

Genauso ist das hier mit Vererbung: die geht ganz grundsätzlich und ist für manche (eher sehr wenige) Fälle das richtige, hier ist sie aber falsch

Ja das mit dem super muss in dem Falle nicht sein.
Nur wenn du dem TE sagst es ist falsch dann erklärt es ihm. So erzeugst du nur noch mehr Verwirrungen .

 

[thecain]

So erzeugst du nur noch mehr Verwirrungen .

mMn hast du mit deiner Antwort die Verwirrung geschaffen indem du gezeigt hast wie es "lauffähig" wäre.

Ist für mich ähnlich, wie wenn jemand fragt wie man auf durchnummerierte Variablen "dynamisch" zugreifen kann. Da zeigt auch immer jemand wie das mit Reflection funktioniert, was nichts zur Lösung oder dem Verständnis beiträgt.

 

[Jw456]

In Post 1 #1
ist nicht die Sichtbarkeit der Instanzvariablen das Problem , die sollten wenn beide Klassen in gleichen Paket sind sichtbar sein.

Vielmehr die die Verwendung.
ersten machst du alles im Klassenrumpf nicht in einer Methode.

Auch ist es nicht sinnvoll jedes Mal ein neues Objekt von Scanner zu erstellen.
In der zweiten Klasse machst du auch wider alles im Klassenrumpf.

Ja das mit den super ist notwendig wenn du eine Methode aus der Kasse überschreiben willst von der du erbst. Sonst brauchst du das nicht.

 

[mihe7]

@Jw456, das ist zwar alles richtig, nur beantwortet das die Frage des TE nicht. Der dürfte jetzt maximal-verwirrt sein

Unabhängig von irgendwelchem Code ist das Hauptproblem das Verständnis dafür, wie ein Objekt an Daten eines anderen Objekts kommt, um damit arbeiten zu können.

Hierfür Vererbung zu verwenden, ist grundlegend falsch. Der Ansatz funktioniert auf Objektebene in keinster Weise, da die Attribute und Methoden zwar vererbt werden, wodurch aber kein Datenaustausch von Attributwerten zwischen Objekten stattfindet.

Jetzt könnte man argumentieren, dass auf Typebene Vererbung funktioniert, was nicht ganz von der Hand zu weisen ist, schließlich hat man in Klasse2 die gleichen Attribute wie in Klasse1 zur Verfügung, wenn Klasse2 von Klasse1 erbt. Damit hätte die Vererbung aber den alleinigen Zweck, Implementierung weiterzugeben und das ist der denkbar schlechteste Grund, Vererbung einzusetzen, da sie die stärkste Form der Kopplung darstellt.

 

[bytestream]

Dieser Code kompiliert aus zwei Gründen nicht:
a) Du deklarierst in der Klasse1 das Feld eingabe1 zweimal.
b) Es gibt keine implizite Typkonvertierung von double nach int (Zeile 12)

Außerdem musst du den Wert von eingabe1 nicht aktiv in Klasse2 holen. Instanzen von Klasse2 kennen das Feld eingabe1 von Klasse1.

public class Klasse1 {
    int eingabe1 = 42;
}

public class Klasse2 extends Klasse1 {
    double result = eingabe1*(Math.random());
}

 

[mrBrown]

Dieser Code kompiliert aus zwei Gründen nicht:

...Und selbst wenn er kompiliert, ist er wie schon X mal gesagt Unsinn, weil man das eigentliche Problem damit nicht löst...

 

[Wuast]

Vielen Dank an alle für die rege Teilnahme, ich bin nun einige Fehler weiter und deutlich schlauer als vorher 😁

 

[Wuast]

Ich greife zum Verständnis das Thema Vererbung nochmal auf, da ich da jetzt glaube ich etwas weiter bin

Wenn ich verschiedene Klassen habe, z.B.
Auto, Kleinwagen, Mittelklasse, Oberklasse, Smart, BMW, BMW z3, BMWA z4, usw.
ließe sich das ja in einer Art Baumdiagramm darstellen und die Logik dahinter erschließt sich denke ich selbst.

Dabei macht es ja auf den ersten Blick schon Sinn, dass Kleinwagen, Mittelklasse, Oberklasse bestimmte Methoden von Auto erben.
Ggf. gilt das ja auch für die Markenklassen wie z.B. BMW. Wenn BMW jetzt von Auto erbt, kann z1 aber nicht von BMW erben, also wäre das eine Mehrfachvererbung oder gilt dies nur, wenn ich z.B. z1 extends BMW extends Auto (wie auch immer die Syntax korrekt lauten würde) schrieb?

public class Auto (){
    int preis = new java.util.Scanner(system.in).nextInt();
  
    if (preis>10000){
        int versicherungssumme = 1000;
    }
    else if (preis<1000){
        int versicherungssumme = 500;
    }
}

public class Kleinwagen() extends Auto {
  
    // was auch immer die Klasse so bereithält
  
}

public class smart() extends Kleinwagen{

// damit würde smart von Kleinwagen erben, die wiederum von Auto geerbt hat?!

}

Habe ich es richtig begriffen, dass die Vererbung nur dann sinnvoll ist, wenn ich sehr allgemeine Methoden (dann in einer Superklasse) habe und somit quasi - wenn ich es mir sinnbildlich mithilfe des Baumdiagramms vorstelle - von unten nach oben (unten = Auto, ganz oben wäre dann die z1 klasse) vererbe?
Oder gibt es auch Situationen, in denen ich von "unten nach oben" vererbe, also dass z.B. BMW etwas an Auto vererbt? ODER wäre das dann eben jenes Bsp. mit den Kartons über DHL in meiner Garage abstellen lassen (geht, ist aber Schwachsinn), wo man eben auch keine Implementierung weiter geben würde (wie mihe es beschreibt)?

 

[thecain]

Du musst dir immer die Frage stellen, ob es wirklich eine Spezialisierung ist. Unterscheidet sich ein BMW wirklich von einem VW? Würde es nicht reichen, einfach einen Hersteller als Attribut zu führen.

Zusätzlich gibt es noch den Grundsatz Composition over Inheritance, dazu spuckt dir Google auch super Ergebnisse aus.

Oder gibt es auch Situationen, in denen ich von "unten nach oben" vererbe, also dass z.B. BMW etwas an Auto vererbt?

Nein, wie auch? BMW wäre eine Spezialisierung von Auto.

 

[Wuast]

Du musst dir immer die Frage stellen, ob es wirklich eine Spezialisierung ist. Unterscheidet sich ein BMW wirklich von einem VW?

Kommt ja auf die Eigenschaft an, die ich beleuchte. Wenn es um das Logo geht oder um die Größe der Klagewelle wegen eventuellen Abgas-Skandalen.. vllt. ja schon
Aber wird eine Vererbung nicht dann eingesetzt, wenn es eben KEINEN Unterschied gibt der eine Neucodierung einer Methode oder ganzen Klasse rechtfertigen würde? Also z.B. Haben VW und BMW ja beide Kombis oder Limousinen. Wenn die Klasse Auto jetzt eine Methode limousinenBepreisen und eine Methode kombisBepreisen hat, könnte ich doch an VW und BMW vererben?!

 

[Wuast]

Nein, wie auch? BMW wäre eine Spezialisierung von Auto.

Gut =) Dann ist das zumindest schommal klar. Bleibt nur noch das abschließende Verständnis dafür, wann ich definitiv eine Vererbung benutzen sollte und wann nicht.

edit: Ups, das hier sollte in die erste Antwort mit rein..

 

[mihe7]

@Wuast, Dein Beispiel ist etwas ungünstig konstruiert. Grundsätzlich kann man über belibig viele Ebenen vererben, z. B. ist ein Auto ein Kraftfahrzeug und ein Kraftfahrzeug ist ein Fahrzeug. In diesem Beispiel erbt jeder Subtyp immer nur von einem Supertypen.

Ein Kraftfahrzeug hat im Vergleich zu anderen Fahreugen z. B. einen Motor. Bei solchen Fahrzeugen können wir z. B. "Gas geben".

Nehmen wir jetzt mal Fahrräder dazu. Ein Fahrrad ist ein Fahrzeug. Man kann dort treten. Soweit, so gut.

Wo stecken wir jetzt ein Mofa hin? Ein Mofa wäre einerseits ein Fahrrad (wir können treten), andererseits ein Kraftfahrzeug (wir können Gas geben). Das könnte man in diesem Modell per Mehrfachvererbung darstellen: ein Mofa ist-ein Fahrrad und ein Mofa ist-ein Kraftfahrzeug.

Mehrfachvererbung gibts in Java nur am Rande. In C++ sieht das anders aus.

Bleibt nur noch das abschließende Verständnis dafür, wann ich definitiv eine Vererbung benutzen sollte und wann nicht.

So wenig Vererbung wie möglich, so viel wie nötig. Überhaupt nur dort, wo Du tatsächlich eine Beziehung der Form "ist ein(e)" zwischen Klassen darstellst.

Vererbung ist nicht so einfach, wie sie auf den ersten Blick aussieht. Man muss nämlich berücksichtigen, dass der Subtyp überall dort verwendet werden kann, wo der Supertyp erwartet wird (es gilt ja die ist-ein-Beziehung). Ist das logisch nicht sinnvoll möglich, ist eine Vererbung theoretisch unzulässig.

 

[Wuast]

Mehrfachvererbung gibts in Java nur am Rande. In C++ sieht das anders aus.

Das Wort hatte ich nur angeschnitten, weil es in der Insel heißt, die Mehrfachvererbung gäbe es nur auf indirektem Weg, im Gegensatz zu z:B. c++ oder Python.

So wenig Vererbung wie möglich, so viel wie nötig. Überhaupt nur dort, wo Du tatsächlich eine Beziehung der Form "ist ein(e)" zwischen Klassen darstellst.

Vererbung ist nicht so einfach, wie sie auf den ersten Blick aussieht. Man muss nämlich berücksichtigen, dass der Subtyp überall dort verwendet werden kann, wo der Supertyp erwartet wird (es gilt ja die ist-ein-Beziehung). Ist das logisch nicht sinnvoll möglich, ist eine Vererbung theoretisch unzulässig.

Also Ein BMW ist ein Auto. Ein z1 ist ein BMW ist ein Auto. Ein z1 ist ein ein BMW, ist ein Mittelklassewagen, ist ein Auto.

Schreibe ich jetzt z1 extends BMW, erhält z1 alles was BMW bereithält, (nur zum Verständnis, obs sinnvoll ist (oder wohl eher) nicht sei dahingestellt) und BMW extends Auto enthält schonmal alles, was Auto bereithält. Und auf diesem Wege erhält z1 quasi über BMW alles von Auto, aber eben über den Umweg BMW - die Klasse könnte ja theoretisch noch was in den Methoden rumfuschen oder etwas ergänzen.

Ist das so korrekt oder noch nicht?

 

[mihe7]

Ist das so korrekt oder noch nicht?

Ja.

 

[mihe7]

Wirf mal einen Blick in die JavaDocs, z. B. https://docs.oracle.com/javase/8/docs/api/javax/swing/JButton.html

Dort siehst du oben die Hierarchie: die Klasse JButton erbt von AbstractButton, die von JComponent, die von Container, die von Component und die von Object.

Ein Stück weiter unten findest Du die Methoden. Dort sind erstmal die aufgeführt, die in JButton definiert wurden. Danach siehst Du die Methoden jeder (ggf. indirekten) Oberklasse.

 

[Wuast]

Super, danke! Es folgen bestimmt weitere Fragen

 

[LimDul]

So wenig Vererbung wie möglich, so viel wie nötig. Überhaupt nur dort, wo Du tatsächlich eine Beziehung der Form "ist ein(e)" zwischen Klassen darstellst.

Das kann ich nur unterschreiben. Vererbung sollte man sehr sehr sparsam einsetzen.

Mal ein Beispiel aus der Praxis (etwas verfremdet). Wir machen eine Software um Verträge zu verwalten. Auf diesen Verträgen kann man sogenannte Geschäftsvorfälle durchführen (z:B. Neugeschäft, Änderung, Kündigung etc.)
Das ganze in einem Konzern mit mehreren Teil-Bereichen/Sparten. Mal als Beispiel ein Telekommunikationskonzern mit der Handy-Verträge und Kabelverträge verkauft.

Nun gibt es ein Grundobjekt "GeVo". Davon gab es dann die Ableitung HandyGeVo und KabelGeVo. Davon wieder HandyNeugeschaeftGeVo und KabelNeugeschaeftGeVo.

Problem: Es gibt sowohl Logik, die Sparten-Spezifisch ist, das heißt, wo es sinnvoll ist die Ableitungs-Hierarchie in Kabel & Handy zu trennen. Aber es gibt auch Logik, die Nuegeschäfts oder Kündigungsspezifisch ist - das bekommt man jetzt nicht mehr abgebildet und muss Code duplizieren.

Das heißt sinnvoller als diese Hierarchie ist eher eine Kompositio, dass man ein Objekt GeVo hat mit sehr wenig Ableitungen zusätzlich als Assoziation eine Beziehung zu Besondernheiten die bei diesem GeVo ausgeführt werden.