Java-Vererbungsproblem

[Unregistered]

Habe zwei Klassen: Father und Son. Son erweitert Father.


class Father {

private String nameCla = "FatherCla";
private String nameKon;

public Father(String nameKon) {
this.nameKon = nameKon;
}

public String getName() {
return nameCla + nameKon;
}

public static void main(String[] args) {

Father father = new Father(" FatherKon");
Son son = new Son(" SonKon");

System.out.println("Father says: " + father.getName());
System.out.println("Son says: " + son.getName());

}
}

********************

class Son extends Father {

private String nameCla = "SonCla";
private String nameKon;

public Son(String nameKon) {
super(nameKon);
}
}

*********** AUSGABE **********

Father says: FatherCla FatherKon
Son says: FatherCla SonKon


Ich habe erwartet:

Father says: FatherCla FatherKon
Son says: SonCla SonKon

Ich weiss nur nicht, warum der Java-Code nicht das macht, was er soll :/

Kann mir da bitte jemand helfen?

[Xmas]

Originally posted by Unregistered
Habe zwei Klassen: Father und Son. Son erweitert Father.


class Father {

private String nameCla = "FatherCla";
private String nameKon;

public Father(String nameKon) {
this.nameKon = nameKon;
}

public String getName() {
return nameCla + nameKon;
}

public static void main(String[] args) {

Father father = new Father(" FatherKon");
Son son = new Son(" SonKon");

System.out.println("Father says: " + father.getName());
System.out.println("Son says: " + son.getName());

}
}

********************

class Son extends Father {

private String nameCla = "SonCla";
private String nameKon;

public Son(String nameKon) {
super(nameKon);
}
}

*********** AUSGABE **********

Father says: FatherCla FatherKon
Son says: FatherCla SonKon


Ich habe erwartet:

Father says: FatherCla FatherKon
Son says: SonCla SonKon

Ich weiss nur nicht, warum der Java-Code nicht das macht, was er soll :/

Kann mir da bitte jemand helfen?
Der Java-Code macht was er soll, nur nicht das was du willst ;)

Um es mal in C++ Scope Notation aufzuzeigen (ich weiß nicht ob es sowas in Java gibt):
Son::nameCla überdeckt Father::nameCla, allerdings nur innerhalb von Son. Father::getName() kann auch nur auf Father::nameCla und Father::nameKon zugreifen.

Selbst wenn der Code das machen würde was du willst, würdest du nicht "Son says: SonCla SonKon" bekommen, sondern nur "Son says: SonCla". Weil du Son::nameKon gar nicht initialisierst.


Was du willst ist eher:

class Father {

protected String nameCla;
protected String nameKon;

public Father(String nameKon) {
this.nameKon = nameKon;
nameCla = "FatherCla";
}

public String getName() {
return nameCla + nameKon;
}

public static void main(String[] args) {

Father father = new Father(" FatherKon");
Son son = new Son(" SonKon");

System.out.println("Father says: " + father.getName());
System.out.println("Son says: " + son.getName());

}
}

********************

class Son extends Father {

public Son(String nameKon) {
super(nameKon);
nameCla = "SonCla";
}
}

[Unregistered]

Originally posted by Xmas
Son::nameCla überdeckt Father::nameCla, allerdings nur innerhalb von Son. Father::getName() kann auch nur auf Father::nameCla und Father::nameKon zugreifen.
getName() wird doch von Son aus Father geerbt.
Ich verstehe nicht, warum Son::getName() nicht den Inhalt von Son::nameCla und Son::nameCon zurückgibt.

[Xmas]

Originally posted by Unregistered

getName() wird doch von Son aus Father geerbt.
Ich verstehe nicht, warum Son::getName() nicht den Inhalt von Son::nameCla und Son::nameCon zurückgibt.
Na eben weil es nur geerbt ist. Für getName() existiert Son überhaupt nicht. getName() operiert sozusagen nur auf Father-Ebene. Deswegen kann es auch auf private Member von Father zugreifen, was jegliche Methoden, die in Son neu hinzukommen, nicht dürfen.

[Gast]

Ein zögerndes "Aha" von mir.

Dann verstehe ich nicht, wozu Vererbung gut ist.

Was bringt mir eine Methode, die an eine Subklasse vererbte wird, wenn man sie in der Subklasse nicht so verwenden kann, wie sie in der Superklasse funktioniert?
Da muss ich die Methode ja in allen Subklassen dennoch wieder selber schreiben ??? .


Andererseits kann es auch sein, dass ich überhaupt nicht kapiert habe, wozu Vererbung gut ist. Das ist naheliegender, als der Unsinn der Vererbung ;) ...

[grakaman]

NameCla und NameKon sind als private deklariert und demzufolge können abgeleitete Typen nicht darauf zugreifen. Ich kenne mich allerdings mit Java null aus. Was bedeutet denn die super Methode im Son Konstruktor? Am besten ist wohl, dass du in der Father Klasse die Member als protected deklarierst und in der Son nicht noch mal neu definierst sondern einfach die Werte setzt. Und dann müsstest du eigentlich den Konstruktor in Son noch explizit sagen, dass er von Father erben soll. Wie das aber in Java aussieht, keine Ahnung.

MfG

[Achill]

@Gast, ziel sollte sein, das du weniger aufwand hast.

Durch erben kann man einer neuen Datenstrucktur (hier klasse) die selben Eigenschaften von der Klasse geben, von der man erbt.

Bsp.: Stell dir mal vor, du müsstest jedes Applet neu Deklarieren und dann die nötigen funktionen implemtieren - das wäre ein heiden Aufwand, so erbst du von Applet und deine neue eigene Klasse hat alle Eigenschaften von Applet - erst einmal ;).

Nun musst du nur noch die Methoden überschreiben/überladen, die du nutzen willst...

Die Umsetzung ist immer vom allgemeinen zum speziellen,
bsp.: Du willst eine Famiele verwalten, man braucht also so eine Klasse für weibl. Menschen und männlichen Menschen - unterscheiden sich ja ;).
Um dir Arbeit zu erleichtern und nicht alles zweimal schreiben zu müssen, schreibst du eine Klasse Mensch, die alles beinnhaltet, was ein Mann und eine Frau gemeinsam haben.
Dann musst du nur noch zweite weiter Klassen anlegen, die von dieser Menschklasse erben (Klasse Mann und Klasse Frau), da jede schon sämtliche gemeinsammen eigenschaften durch das erben besitzen, musst du nur noch die speziellen Eigenschaften hinzu fügen.
Man hat sich dadurch code gespart, indem man die gemeinsem Eigenschaften nur einmal in Mensch deklariert/implementiert und nur noch den Code für die unterschiedlichen Merkmale hinzu fügen muss...

ich denke mal das ist einer der Gedanken, der hinter OOP steht, weiter geht es mit vorzügen der kapselung ect.

[Xmas]

Original geschrieben von Gast
Ein zögerndes "Aha" von mir.

Dann verstehe ich nicht, wozu Vererbung gut ist.

Was bringt mir eine Methode, die an eine Subklasse vererbte wird, wenn man sie in der Subklasse nicht so verwenden kann, wie sie in der Superklasse funktioniert?
Da muss ich die Methode ja in allen Subklassen dennoch wieder selber schreiben ??? .


Andererseits kann es auch sein, dass ich überhaupt nicht kapiert habe, wozu Vererbung gut ist. Das ist naheliegender, als der Unsinn der Vererbung ;) ...

Es gibt zwei generelle Zwecke der Vererbung, einerseits die Weitergabe von Funktionalität, und andererseits die Definition eines gemeinsamen Aufbaus/Interfaces.

Die Weitergabe der Funktionalität bedeutet aber, dass genau diese Funktionalität weitergegeben wird, und dass sich alle übernommenen Memberfunktionen genau so verhalten als würden sie für eine Instanz der Basisklasse aufgerufen. Der Code für die Methode wird nur einmal generiert, nicht in jeder abgeleiteten Klasse neu.

Zudem deklarierst du ja in deinem Beispiel die Member-Variablen als private. Private-Member existieren nur inerhalb dieser Klasse und werden nicht vererbt. Wenn du in der abgeleiteten Klasse neue Variablen deklarierst, haben die gar nichts mit denen aus der Basisklasse zu tun, selbst wenn sie denselben Namen haben.

[Xmas]

Original geschrieben von grakaman
NameCla und NameKon sind als private deklariert und demzufolge können abgeleitete Typen nicht darauf zugreifen. Ich kenne mich allerdings mit Java null aus. Was bedeutet denn die super Methode im Son Konstruktor? Am besten ist wohl, dass du in der Father Klasse die Member als protected deklarierst und in der Son nicht noch mal neu definierst sondern einfach die Werte setzt. Und dann müsstest du eigentlich den Konstruktor in Son noch explizit sagen, dass er von Father erben soll. Wie das aber in Java aussieht, keine Ahnung.

MfG
super() ruft den Konstruktor der Basisklasse auf. Ansonsten habe ich ja schon geschrieben wie der Code aussehen müsste.