Konstruktor, Instanzvariablenvererbung

[b1zarRe]

Hi,

ich verstehe folgendes nicht:

public class A {
   //Instanzvariablen
  public int a = -1;

  //Konstruktor
  public A() {}

  //Methode
  public int gibA() {
     return this.a;
  }
}
----------------------------------------------------------
public class D extends A {
  //Instanzvariablen
  public int a = 100;

  //Konstruktor
  public D() {}

  //Methode
  public int gibEinA() {
    return super.gibA();
  }
}
----------------------------------------------------------
public class Test {
  public static void main(String[] args) {
     D d = new D();
     System.out.println(d.gibEinA());
     System.out.println(d.a);
  }
}
----------------------------------------------------------

Normalerweise(angefangen bei der "D" Klasse) müsste es ja zunächst der
D-Konstruktor aufgerufen werden, welcher quasi ein "unsichtbares" super() in der ersten
Zeile stehen hat. Also geht es "rauf" zu der A-Klassen-Konstruktor und danach wieder
zurück zum Konstruktor von D.

Sobald die Methode d.gibEinA() ausgeführt wird will er ja "super.gibA()" rechnen, und
geht also in die Oberklasse wo steht: return this.a. Nun, ich dachte immer "this" würde sich
immer auf das ursprüngliche Objekt beziehen, und somit müsste doch 100 herauskommen, so
wie es in Klasse D steht und nicht etwa -1. Okay, man kann wohl schlussfolgern, wenn man
in D Konstruktor nicht stehen hat a = 100 dann nimmt er einfach das a von der Oberklasse.
Stimmt aber auch nicht... er nimmt weiterhein -1 als Ergebnis. Nun könnte man schlussfolgern,
dass er einfach bei Namensgleichheit von Variablen in einer Vererbung einfach immer die höhere Variable nimmt und deshalbt -1 herauskommt und beim zweiten Aufruf deshalb die Variable von der wirklichen Klasse.

Irgendwie verwirrt mich das gerade zutiefst... Mag das vielleicht jemand erläutern warum das
so ist :autsch:

Denn, wenn ich folgendes stehen hätte:

public class A {
    public int a;
    public int b;

    public A() {
        this.a = 0;
        this.b = 40;
    }
    public void erhoehe(int summand) {
        a = a + summand;
    }
    public int gibWert() {
        return 2 * a;
    }
}
----------------------------------------------------------
public class B extends A {
    public int b;

    public B() {
        this.a = 10;
        this.b = 100;
    }

    @Override
    public int gibWert() {
        return b * super.gibWert(); 
    }
}
----------------------------------------------------------
public class Test {
    private static void testeSuper() {
        A a = new A();
        B b = new B();

        b.erhoehe(20);
        System.out.println(b.gibWert());
    }
 public static void main(String[] args) {
        testeSuper();
    }
}
----------------------------------------------------------

Benutzt er anscheinend nicht einfach das a bzw. b von der Oberklasse sondern
das von der Instanzklasse.... Also in diesem Fall von der Klasse B.

 

[FrozenBrain]

Eins vorweg: Konstruktoren werden nicht vererbt, lediglich Methoden und Attribute.

Du hast bei dir das Problem, dass du in sowohl Ober- als auch in der Unterklasse das Attribut "a" definierst. Methoden kannst du auf diese Weise überschreiben, Attribute allerdings nicht. Java behandelt die beiden "a"-Attribute daher so, als wären sie unterschiedliche Attribute (wie als hättest du zwei mit unterschiedlichem Namen), entsprechend wird die Methode das "a" der Oberklasse zurückgegeben. Wenn du in deiner Unterklasse einen anderen Wert für "a" haben möchtest, müsstest du den Wert im Konstruktor überschreiben (die erneute Deklaration von "a" fällt weg).

In deinem zweiten Code tust du genau das. Du gibst dem "b" deiner Unterklasse (da sie "b" als eigenes Attribut hat) und dem "a" der Oberklasse neue Werte im Konstruktor. Die Methode "erhoehe" arbeites deshalb auch mit dem neuen Wert von "a".

 

[b1zarRe]

Okay danke.

Habe ich denn dann bei dem 2. Beispiel immernoch zwei unterschiedliche a's bzw. b's?
Oder gibt es davon jetzt nurnoch jeweils eins, weil diese in dem Konstruktor einen neuen Wert erhalten haben?

Bei dem ersten Beispiel, habe ich ja den Wert für a direkt initalisiert. Spielt das keine Rolle? Sprich: Ist in dem Fall nur wichtig,
was die Konstruktoren machen und irrelevant, wie die Instanzvariablen machen? Ich dachte bisher, dass wenn ich eine
Instanz einer Klasse erstelle, zuerst der(bzw. die) Konstruktor(en) ausgeführt werden und danach oder davor auch
deren Instanzvariablen "erstellt" werden. Deshalb dachte ich bei Beispiel 1, dass das geerbte a überschrieben wird.

Ps.: Das Konstruktoren nicht vererbt werden weiß ich, aber diese werden ja nacheinander abgearbeitet, da bei einem Default-Konstruktor public B() {} quasi zunächst der Konstruktor der Oberklasse abgearbeitet wird.

 

[FrozenBrain]

Im Prinzip hast du schon Recht. Wird ein Objekt erstellt werden die Attribute deklariert und gegebenenfalls initialisiert und der Konstruktor aufgerufen (erst Attribute, dann Konstruktor).

Bei deinem 2. Beispiel hat Klasse "A" ein eigenes "a" und ein eigenes "b". Klasse "B" hat nur ein eigenes (zusätzliches) "b".

Wird der Konstruktor von Klasse "B" aufgerufen wird das "b" von Klasse "B" auf 100 gesetzt und das "a" der Klasse "A" (welches vererbt wird) auf 10. Wann du die Werte zuweist ist prinzipiell egal. Wichtig nur, wo du die Attribute deklarierst. Sprich: Wenn du in Oberklasse und Unterklasse zwei gleichnamige Attribute deklarierst, hat jede Klasse für das Attribut mit dem Namen auch seinen eigenen Wert.