Vererbung/Dynamische Bindungen

[neXes]

Hallo,

habe eine kleine Frage zu den allseits beliebten dynamischen Bindungen (ich bin mir zumindest relativ sicher, dass es sich bei meiner Frage auch tatsächlich darum dreht).

Folgender Code stammt aus einem Java-Buch:

class AKlasse {
  public int wert = 0;
  public int wert() {
    return this.wert;
  }
}

/* ****************************************************************** */

class CKlasse extends AKlasse {
  public int wert = 1;
  public int wert() {
    return this.wert;
  }
}

/* ****************************************************************** */

public class ElchTest {
  public static void main(String argv[]) {
    AKlasse a = new AKlasse();
    System.out.println("Wert von a ist: " + a.wert);
    System.out.println("Wert von a ist: " + a.wert());
    CKlasse b = new CKlasse();
    System.out.println("Wert von b ist: " + b.wert);
    System.out.println("Wert von b ist: " + b.wert());
    AKlasse c = b;
    System.out.println("Wert von c ist: " + c.wert);
    System.out.println("Wert von c ist: " + c.wert());
  }
}

Die Ausgabe lautet:

Wert von a ist: 0
Wert von a ist: 0
Wert von b ist: 1
Wert von b ist: 1
Wert von c ist: 0
Wert von c ist: 1

Die Ausgabe von "a" ist mir klar. Die Ausgabe von "b" erklär ich mir folgendermaßen. Attribute und Methoden werden an die Unterklassen vererbt, in diesem Fall jedoch überschrieben (richtig?). Die Ausgabe von "c" kann ich jedoch nicht ganz nachvollziehen. Die Variable c bekommt doch in Zeile 28 ein CKlasse-Objekt zugewiesen, welches den Wert 1 hat, warum also die Ausgabe 0? Ist nicht immer der tatsächliche Typ des Objektes relevant (hier: CKlasse) und nicht der deklarierte (hier: AKlasse)? Und selbst wenn das Attribut von c den Wert 0 hat, warum gibt die Methode 1 aus?

Ich befürchte der Groschen ist bei dieser Thematik noch nicht gefallen und bedanke mich bereits im Voraus für etwaige Erklärungsversuche!

 

[Schandro]

CKlasse erbt zwar von AKlasse, besitzt aber eine eigene Membervariable wert, die leider genauso heisst wie die aus AKlasse. Es ist nicht diesselbe, sondern eine neue!

    CKlasse b = new CKlasse();
    System.out.println("Wert von b ist: " + b.wert); // hier wird die Variable von CKlasse genommen
    System.out.println("Wert von b ist: " + b.wert());
    AKlasse c = b; // "c" bezieht sich zwar auf dasselbe wie "b", wurde aber ge-downcastet
    System.out.println("Wert von c ist: " + c.wert); // hier wird die Variable von AKlasse genommen
    System.out.println("Wert von c ist: " + c.wert());

Die Methode c.wert() gibt aber beides mal dasselbe aus, trotz des downcast, weil diese schließlich in CKlasse überschrieben wurde.

 

[neXes]

Vielen Dank für deinen Erklärungsversuch. Ich befürchte jedoch, dass er eine Nummer zu schnell für mich war. Mein Verständnisproblem liegt offenbar in folgender Zeile:

AKlasse c = b; // "c" bezieht sich zwar auf dasselbe wie "b", wurde aber ge-downcastet

Kann mir evtl. jemand erklären was in dieser Zeile genau passiert? Nach meinem Verständnis hat man durch die Superklasse "AKlasse" hier den Vorteil, dass eine Variable dieses Typs (hier: c) auch auf Objekte der Subklassen verweisen kann (ich hoffe ich hab mich richtig ausgedrückt?!). Was hat es jedoch mit dem hier angesprochenen "downcast" auf sich? Habe mal kurz gegoogelt und habe mir gemerkt downcast ~ ableiten? Warum aber wurde c abgeleitet von b, schließlich ist AKlasse doch die Superklasse und in wie wirkt sich das auf das Attribut "wert" aus :bahnhof:

Ich denke mal meine Fragen sind für euch selbstverständlich und unter eurem Niveau, hoffe aber dennoch, dass ihr noch ein bisschen Geduld mit mir habt

 

[hdi]

Die Methode wert() in CKlasse überschreibt die Methode wert() in AKlasse.
Die Variable wert inCKlasse dagegen überschattet die Variable wert in AKLasse.

Wenn man auf Methoden zugreift, wird immer die von derjenigen Klassen genommen,
von deren speziellsten Typ das Objekt ist, sprich die unterste Unterklasse sozusagen.
(Falls die Methode dort exisitert, also überschrieben wurde, ansonsten geht's eine Ebene höher usw)

Wenn man aber direkt auf Variablen zugreift, und nicht über Methoden, wird immer der Wert von
derjenigen Klasse hergenommen, von deren allgemeinsten Typ das Objekt ist.
Und das ist hier eben AKlasse.

Also Methoden -> "Override"
und Attribute -> "Overload"

Ich kann dich aber beruhigen: Solche Probleme wirst du niemals wirklich haben, weil man Attribute immer
private macht. Dadurch sind sie nach außen hin nicht sichtbar und man kann gar nicht direkt darauf
zugreifen

 

[Schandro]

Wenn man aber direkt auf Variablen zugreift, und nicht über Methoden, wird immer der Wert von
derjenigen Klasse hergenommen, von deren allgemeinsten Typ das Objekt ist.

Nur um mal einen Begriff zu klären:
Der allgemeinste Typ im Falle von "c" bei
CKlasse c = new CKlasse();
ist CKlasse, oder? Ansonsten würd dein Satz nicht mit der Realität von neXes übereinstimmen

 

[hdi]

Der allgemeinste Typ im Falle von "c" bei
CKlasse c = new CKlasse();
ist CKlasse, oder?

Ja klar, wenn du links und rechts vom "=" den exakt gleichen Typ hast brauchst du dir eh keine
Gedanken machen, dann ist ja klar welche Methoden und Attribute benutzt werden.

Nur zB bei

AKlasse c = new CKlasse();

ist der allgemeinste Typ "AKlasse" und der speziellste Typ "CKlasse",
weil CKLasse eine Unterklasse von AKlasse ist.

 

[neXes]

Die Methode wert() in CKlasse überschreibt die Methode wert() in AKlasse.
Die Variable wert inCKlasse dagegen überschattet die Variable wert in AKLasse.

Wenn man auf Methoden zugreift, wird immer die von derjenigen Klassen genommen,
von deren speziellsten Typ das Objekt ist, sprich die unterste Unterklasse sozusagen.
(Falls die Methode dort exisitert, also überschrieben wurde, ansonsten geht's eine Ebene höher usw)

Wenn man aber direkt auf Variablen zugreift, und nicht über Methoden, wird immer der Wert von
derjenigen Klasse hergenommen, von deren allgemeinsten Typ das Objekt ist.
Und das ist hier eben AKlasse.

Also Methoden -> "Override"
und Attribute -> "Overload"

Vielen Dank für deine ausführliche Antwort! Habe es jetzt verstanden und merke mir die beiden letzten zitierten Zeilen von dir, was sich möglicherweise auch der Autor dieser Aufgabe gewünscht hat :wink:

 

[hdi]

Ich würde an deiner Stelle aber trotzdem nochmal warten, bis das einer der Profis hier bestätigt hat,
was ich geschrieben habe

Ich bin zwar kein Anfänger mehr aber gerade bei solchen Definitionen und komischne Bsp fühle ich mich
noch oft ein wenig wacklig auf den Beinen. Kann dir jetzt nicht zu 100% sagen ob das so korrekt war.

PS: Allgemein: Ich hab zB ein Projekt "GoodToKnow", dort speicher ich mir immer kleine ausführbare Bsp
von solchen Dingen wie dem hier ab. Da sind auch Dinge von Call-By-Refernce drin, static vs. dynamic usw.
Kann ich nur empfehlen, denn sowas vergisst man leider viel zu schnell, weil man auch nur seltener damit
konfrontiert ist.

 

[Niki]

...Wenn man aber direkt auf Variablen zugreift, und nicht über Methoden, wird immer der Wert von
derjenigen Klasse hergenommen, von deren allgemeinsten Typ das Objekt ist.
Und das ist hier eben AKlasse...

Es wird nicht auf die Variable der allgemeinsten Klasse zugegriffen, sonder auf den Typ der Deklaration.

Beispiele:

public class A {
    String x = "A";
}

public class B extends A{
    String x = "B";
}

public class C extends B{
    String x = "C";
}

C c = new C();
System.out.println(c.x + " " + c.x);
B b = c;
System.out.println(c.x + " " + b.x);
A a = c;
System.out.println(c.x + " " + a.x);

--->
C C
C B
C A

 

[hdi]

Genau, sag ich doch:

wird immer der Wert von derjenigen Klasse hergenommen, von deren allgemeinsten Typ das Objekt ist.

Also auf deutsch: Die Klasse, die links vom "=" stand als das Objekt erzeugt wurde.

 

[Niki]

Der Typ bei der Erzeugung ist egal wie du bei dem Beispiel siehst. Der Typ auf den gecastet wird ist relevant. Von dem wird nämlich das Attribut genommen.

 

[hdi]

Ja okay das mit dem "Objekt ist" ist falsch ausgdrückt. Aber wir meinen das gleiche.
Eben die Klasse, von deren Typ die Variable definiert wird (und nicht die Klasse deren Objekt dann
dort reingespeichert wird)

 

[Niki]

genau :wink:

 

[Ebenius]

Die Methode wert() in CKlasse überschreibt die Methode wert() in AKlasse.
Die Variable wert inCKlasse dagegen überschattet die Variable wert in AKLasse.

Ich bin begeistert... So stimmt's.

Also Methoden -> "Override"
und Attribute -> "Overload"

Einzig und allein der Terminologie wegen:

• Methoden werden überschrieben → Override
• Attribute werden überschattet → Shadowing
• Operatoren werden überladen (was in Java nur für String der Fall ist) → Overload

Ebenius

 

[André Uhres]

1234567890

 

[Ebenius]

Ein Methodenname wird überladen (und dadurch mehrdeutig).

Stimmt, hätte ich noch hinzufügen sollen. Vor allem ging's mir darum, dass "Überladen" nicht das richtige Wort ist für das Verstecken von Attributen...