Java neues Objekt erstellen - Ablauf

[yxy]

Hallo,

habe ich das richtig verstanden?:

Wenn ich in Jave ein neues Unterklassenobjekt erstelle, dann passiert folgendes:

1. Objekt der Oberklasse wird erstellt
2. Membervariablen werden initialisiert
3. Konstruktor wird aufgerufen

 

[benneq]

Was meinst du mit "Unterklassen"-Objekt?

Sowas?

public class Foo {
  public static class Bar {

  }
}

...

new Foo.Bar();

Da wird mit "Foo" gar nichts angestellt. Das dient hier quasi nur als eine Art Namespace (außerdem bringt es noch ein paar kleine Änderungen für die Sichtbarkeit der Membervariablen mit sich).
Im Endeffekt erstellst du einfach ein Objekt vom Typ "Bar". Ob du die Klasse "Bar" in eine andere Klasse schachtelst, oder in eine eigene Java-Datei packst, ist relativ egal. Für den Programmierer verhalten sich die beiden Klassen vollkommen identisch.

 

[Redirion]

ich glaube mit Unterklasse und Oberklasse ist hier Vererbung gemeint, nicht innere Klassen.

hier ist der relevante Teil der Java Language Specification (JLS). (Example 12.5-1)

 

[yxy]

Vererbung

 

[benneq]

Ah! Dann lautet die Erklärung natürlich anders

In dem Prozess wird "nicht wirklich" ein Objekt der Oberklasse erstellt, aber ein(!) Konstruktor der Oberklasse wird aufgerufen. Aber man kann es sich ruhig so vorstellen, wenn es das einfacher machen sollte.

Z.B. hier:

public class X {
    String s = "a";

    X() {
        System.out.println(s);
        this.s = foo();
        System.out.println(s);
    }

    String foo() {
        return "abc";
    }
}

class Y extends X {
    Y() {
        super(); // kann man weglassen, weil default constructor. Wird dann
                 // automatisch (implizit) ausgeführt
        System.out.println("Y");
    }

    String foo() {
        return "xyz";
    }
}

...

new Y();

Durch "new Y()" wird der Code gestartet. Dadurch wird zuerst der Konstruktor von Y aufgerufen. Bei der Vererbung in Java ist man gezwungen den Konstruktor der Oberklasse (= Superkonstruktor) als ersten Befehl aufzurufen. Das passiert automatisch (= implizit), wenn es sich um Konstruktoren ohne Argumente handelt (= Zero Args Constructor / Default Konstruktor).

Die Reihenfolge ist also:
1. Konstruktor von Y wird aufgerufen.
1.1. Member von Klasse Y werden initialisiert
2. Dieser Konstruktor ruft sofort den Superkonstruktor auf.
3. Der Code vom Superkonstruktor wird ausgeführt:
3.1. Member von Klasse X werden initialisiert
3.2. Ausgabe: "a"
3.3. Ausgabe: "xyz" (weil die Methode foo in Klasse Y überschrieben wurde)
4. Konstruktor von Y wird fortgesetzt
4.1. Ausgabe: "Y"
5. Objekt vom Typ Y fertig erstellt

 

[yxy]

Zum Beispiel in folgendem Programm (siehe Bild).

Ich hätte mir das jetzt so gedacht beim Aufruf in Zeile 45:

1. Objekt der Oberklasse Vehicle wird erstellt
2. Member-Variablen des Vehicle-Objekts werden erstellt
3. Konstruktor des Vehicle-Objekts wird aufgerufen

4. Objekt der Oberklasse Watercraft wird erstellt
(5. Member-Variablen des Watercraft -Objekts werden erstellt)-es gibt keine
6. Konstruktor des Watercraft -Objekts wird aufgerufen

7. Objekt der Klasse SailingBoat wird erstellt
8. Member-Variable "theSails" des SailingBoat -Objekts wird erstellt, dazu
9. Objekt der Klasse Sails wird erstellt
10. Member-Variable des sails-Objekts werden erstellt
11. Konstruktor des sails-Objekts wird aufgerufen
12. Konstruktor des SailingBoat -Objekts wird aufgerufen

---------------------------

Ergänzung (2. Juli 2018)

Ach ok, d.h.

in Wirklichkeit wird dann:
1. Der Konstruktor der Unterklasse aufgerufen.
2. Dieser ruft sofort den Konstruktor der Oberklasse auf
3. Der Konstruktor der Oberklasse erzeugt die Member-Variablen der Oberklasse
4. Der Code im Oberklassenkonstruktor wird ausgeführt
5. Der Unterklassenkonstruktor erzeugt die Member-Variablen der Unterklasse
6. Der Code im Unterklassenkonstruktor wird ausgeführt.

Oder?
Aber letztendlich könnte ich mir es auch so denken wie im 1. Beitrag (ist zwar nicht ganz korrekt, aber führt zum selben Ergebnis)?

 

[benneq]

Ja, klingt richtig. Wie du es dir am Ende einprägst ist ja egal, solang du auf's selbe Ergebnis kommst