Code Verständnis

[JavaAnfaenger96]

Hallo, gegeben sei folgendes Coding:

class Fahrzeug {
    public Fahrzeug() {
        IO.writeln("Fahrzeug erzeugt");
    }

    public void fahre() {
        IO.writeln("Auto fährt");
    }
}

class Auto extends Fahrzeug {
    public Auto() {
        IO.writeln("Auto erzeugt");
    }

    public void fahre() {
        IO.writeln("Auto fährt");
    }
}

class Test {
    public static void testen(Fahrzeug fg) {
        fg.fahre();
    }

    public static void main(String[] args) {
        Fahrzeug f = new Auto();
        testen(f);
        f = null;
    }
}

Meine Frage:
Ich habe den Code in Java so eingegeben und kann die Ausgabe nicht nachvollziehen:

Fahrzeug erzeugt
Auto erzeugt
Auto fährt

Müsste dem Code nach nicht eigentlich nur "Auto fährt" ausgegeben werden? Es wird doch
in der Test Klasse nur fg.fahre aufgerufen und sonst nichts anderes?

​

 

[VfL_Freak]

Moin,

IMHO liegt es an dieser Zeile

Fahrzeug f = new Auto();

Hier deklarierst Du ja eine neue Variable vom Typ 'Fahrzeug', also dürfte implizit der Standart-Konstruktor der Klasse 'Fahrzeug' aufgerufen werden!

VG Klaus

 

[JavaAnfaenger96]

Moin,

IMHO liegt es an dieser Zeile

Fahrzeug f = new Auto();

Hier deklarierst Du ja eine neue Variable vom Typ 'Fahrzeug', also dürfte implizit der Standart-Konstruktor der Klasse 'Fahrzeug' aufgerufen werden!

VG Klaus

Danke für die Antwort! Aber es wird doch die Methode fahre() angesprochen, warum werden dann die anderen Zeilen mit ausgegeben? Habs beim Debugger auch nicht nachvollziehen können.

 

[VfL_Freak]

Aber es wird doch die Methode fahre() angesproche

falsch !!
Mit "new Auto()" wird auch der Konstruktor "public Auto()" angesprochen !!
Und wie gesagt, vermutlich implizit durch Deine Deklaration auch der Konstruktor der Elternklasse "public Fahrzeug" !!

VG Klaus

 

[Joose]

Und wie gesagt, vermutlich implizit durch Deine Deklaration auch der Konstruktor der Elternklasse "public Fahrzeug" !!

Nicht nur vermutlich, bevor der aufgerufene Konstruktor seinen Code ausführt werden noch alle Konstruktoren der Superklassen ausgeführt (sofern welche vorhanden sind usw.)

 

[Harry Kane]

Und wie gesagt, vermutlich implizit durch Deine Deklaration auch der Konstruktor der Elternklasse "public Fahrzeug" !!

Jep, das wird es sein, dass bei einem parameterlosen Konstruktor automatisch der parameterlose Konstruktor der Superklasse aufgerufen wird, sofern ein solcher vorhanden ist.
Die JLS behandelt diesen Punkt leider etwas verwirrend:
https://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.8
Kapitel 8.8.7. Das was mich verwirrt ist fett markiert. vermutlich wollen sie sagen, dass das automatische aufrufen des parameterlosen Konstruktors der Superklasse NICHT erfolgt, wenn die aktuelle Klasse die Klasse Object ist. is ja auch logisch, denn die hat ja keine Superklasse.
"If a constructor body does not begin with an explicit constructor invocation and the constructor being declared is not part of the primordial class Object, then the constructor body implicitly begins with a superclass constructor invocation "super();", an invocation of the constructor of its direct superclass that takes no arguments"

 

[Joose]

Jep, das wird es sein, dass bei einem parameterlosen Konstruktor automatisch der parameterlose Konstruktor der Superklasse aufgerufen wird, sofern ein solcher vorhanden ist.

Achtung: es ist egal ob der eigene Konstruktor parameterlos ist oder nicht! Habe ich eine Superklasse wird trotzdem deren Default Konstruktor (parameterloser Konstruktor) aufgerufen. Die Einzige Ausnahme ist wenn ich einen bestimmten Konstruktor der Superklasse aufrufe!

public class BaseClass {

   public BaseClass() {
       System.out.println("DefaultConstructor - BaseClass");
   }
}

public class ChildClass extends BaseClass {

   public ChildClass() {
       System.out.println("DefaultConstructor - ChildClass");
   }

   public ChildClass(int number) {
       System.out.println("Constructor(int) - ChildClass"); 
   }
}

public class DoubleChildClass extends ChildClass {

   public DoubleChildClass() {
       super(1);
       System.out.println("DefaultConstructor - DoubleChildClass");
   }

   public DoubleChildClass(int number) {
       super();
       System.out.println("Constructor(int) - DoubleChildClass"); 
   }

   public DoubleChildClass(String text) {
       System.out.println("Constructor(string) - DoubleChildClass");   
   }
}

   public static void main(String[] args) {
       new DoubleChildClass();
       new DoubleChildClass(1);
       new DoubleChildClass("");
   }

 

[JavaAnfaenger96]

Vielen Dank für die zahlreichen Antworten! Ein paar Fragen hätte ich noch:
Werden im Body des Konstruktors somit alle system.out.println bzw. IO.writeln Zeilen automatisch ausgegeben?
Das Coding war gegeben. Hat das "f = null" am Ende eine Bedeutung? Denn der Compiler hat beim auskommentieren nichts gesagt.
Und schlussendlich: Wie kann man Coding formtieren, sodass es wie beim ersten Beitrag als solches hervorsteht? In der Menüleiste hab ich nichts dazu gefunden (Das hat übrigens ein Moderator eingefügt )

 

[Joose]

Werden im Body des Konstruktors somit alle system.out.println bzw. IO.writeln Zeilen automatisch ausgegeben?

Der Code in den Konstruktoren wird normal ausgeführt. Wenn dort System.out.print... steht dann wird etwas auf die Konsole geschrieben.

Das Coding war gegeben. Hat das "f = null" am Ende eine Bedeutung? Denn der Compiler hat beim auskommentieren nichts gesagt

Nein diese Zeile macht nichts besonderes, sie entfernt die Referenz von der Variable "f". Da dass Programm nach dieser Zeile eh endet hat es keine Auswirkungen auf die Ausführung.
Bei umfangreicheren Programmen kann so eine Zeile aber schon mal Sinn machen und große Auswirkungen haben ... aber das wirst du dann schon sehen.

Und schlussendlich: Wie kann man Coding formtieren, sodass es wie beim ersten Beitrag als solches hervorsteht? In der Menüleiste hab ich nichts dazu gefunden (Das hat übrigens ein Moderator eingefügt )

Einfach [code=java] .. dein code ...[/code] schreiben

 

[Meniskusschaden]

Mit "new Auto()" wird auch der Konstruktor "public Auto()" angesprochen !!
Und wie gesagt, vermutlich implizit durch Deine Deklaration auch der Konstruktor der Elternklasse "public Fahrzeug" !!

Nur noch mal zur Verdeutlichung, weil das vielleicht etwas mißverständlich formuliert war: Der Konstruktor von Fahrzeug würde auch aufgerufen werden, wenn die Deklaration von f nicht so:

Fahrzeug f = new Auto();

sondern so:

Auto f = new Auto();

aussehen würde. Entscheidend ist, dass die Klasse Auto die Klasse Fahrzeug erweitert.