[JAVA] constructors in 1.3

[GiLuX]

ik las in een java(v1.2.1) boek(deitel&deitel) dat als je een class B hebt die class A extends en je maakt geen constructor aan in in class B dat dan automatisch de (default)constructor van A word aangeroepen.

echter, dit gebeurd niet in v1.3.1

ook stond er dat als ze allebij geen constructor hebben datie dan een fout gooit.

ook dit gebeurd niet onder v1.3.1

is dit allemaal veranderd sinds v1.3?

dat zijn best wel essentieele veranderingen dan....

[Alarmnummer]

Ik plaats zelf overal wel een super constructor bij. Hier is nog een heel aardig artikel op javaworld over het gebruik van constructors:

http://www.javaworld.com/jw-10-2000/jw-1013-constructors.html?

Heb verder geen antwoord op je vraag.

[mbravenboer]

Hoe kom je erbij dat dit niet gebeurt? Heb je een test geschreven? Volgens mij is het gedrag namelijk gewoon normaal.

Ik heb even een test geschreven met 1.4.0:

code:

public class Test extends Test1
{
    public static void main(String[] ps)
    {
        new Test();
    }       
}

class Test1 extends Test2
{
    Test1()
    {
        System.out.println("Test1 Constructor");
    }
}

class Test2
{
    Test2()
    {
        super();
        System.out.println("Test2 Constructor");
    }
}

Als uitvoer zie ik keurig Test2 Constructor en Test1 Constructor. Er wordt dus een Constructor voor test aangemaakt, waarin de super wordt aangeroepen. Ook wordt in de Test1 constructor een super call ingevoegd.

Ik heb hier nog een 1.3.0 liggen en die doet exact hetzelfde. Ik denk dus dat jij iets niet helemaal goed doet. Draai deze test dan ook eens onder jouw 1.3.0?

Overigens is dit allemaal compile-time stuff en het heeft dus alleen met de compiler te maken die gebruikt wordt.

[GiLuX]

volgs mij snap je mijn punt niet.

hier wat code:

code:

public class Test {
    public void bli() {
      System.out.println("blaat");
    }
}

public class Test2 extends Test {
    public void hallo() {
      System.out.println("hallo");
    }
}

(dus allebij zonder constructor)
nu doe ik:
Test2 test2 = new Test2();

output is dan: nix

volgens dat boek zou dit dus een error moeyen gooien.
-----------------------------------------

vervolgens:

code:

public class Test {
    public void Test() {
      System.out.println("class Test constructor ");
    }
}

public class Test2 extends Test {
    public void hallo() {
      System.out.println("hallo");
    }
}

(dus nu alleen Test met constructor)
nu doe ik:
Test2 test2 = new Test2();

output is dan: weer nix

nu zou volgens het boek de default constructor van Test aangeroepen moeten worden omdat class Test2 er geen heeft en er dan automatisch naar de constructor van de class waar die van afgeleid is wordt gezocht en dat is in dit geval Test.

volgens het boek zou dus wel de constructor van Test aangeroepen moeten worden maar dat gebeurd dus niet.

[Onno]

Op woensdag 05 december 2001 16:47 schreef GiLuX het volgende:
(dus allebij zonder constructor)
nu doe ik:
Test2 test2 = new Test2();

output is dan: nix

volgens dat boek zou dit dus een error moeyen gooien.

Waarom een error? De constructor wordt nu toch gewoon overgeerfd van Object?

vervolgens:

code:

public class Test {
    public void Test() {
  System.out.println("class Test constructor ");
    }
}

Dat is geen goede constructor. Een constructor heeft *geen* returntype, zelfs niet void.

[jokke]

Vier classes:

code:

public class SuperClass {
    public SuperClass() {
      System.out.println("de superclasss");
    }
}

public class SubClassZonderConstructor extends SuperClass {
}

public class SubClassMetConstructor extends SuperClass {
     public SubClassMetConstructor() {
      System.out.println("SubClassMetConstructor");
    }

}

public class SubClassMetConstructorExplicitSuper extends SuperClass {

    public SubClassMetConstructorExplicitSuper() {
      super();
      System.out.println("SubClassMetConstructorExplicitSuper");
    }

}

public class TestConstructor {
    public TestConstructor() {
    }

    public static void main (String args[]) {
      System.out.println("\nStart Superclass alleen:");
      Object clazz= new SuperClass();
      System.out.println("\nStart SubClassZonderConstructor:");
      clazz = new SubClassZonderConstructor();
      System.out.println("\nStart SubClassMetConstructor:");
      clazz= new SubClassMetConstructor();
      System.out.println("\nStart SubClassMetConstructorExplicitSuper:");
      clazz= new SubClassMetConstructorExplicitSuper();
    }

}

De output is:

code:

Start Superclass alleen:
de superclasss
Start SubClassZonderConstructor:
de superclasss
Start SubClassMetConstructor:
de superclasss
SubClassMetConstructor
Start SubClassMetConstructorExplicitSuper:
de superclasss
SubClassMetConstructorExplicitSuper

In jdk 1.4 beta3
ofwel, het maakt niet uit of je de super aanroept in je constructor deze wordt altijd uitgevoerd. Als de subclass geen constructor heeft dan wordt ook de constructor van de super uitgevoerd.

[mbravenboer]

Er zou hier inderdaad helemaal geen compiler error opgeleverd hoeven te worden.

Bij klassen wordt er standaard een lege constructor toegevoegd aan de code als je geen constructor maakt voor je klasse. Deze roept de super constructor aan.

Je ziet nu ook gelijk een probleem waarbij je wel compiler errors krijgt: als de super klasse alleen constructoren met parameters heeft, moet die super aanroep dus argumenten meegeven. Dat is een probleem omdat er een lege constructor wordt aangemaakt. Je zult hier dan ook een compile-time melding krijgen dat je een constructor moet maken die een super aanroep doet met argumenten.

Als je in de hele structuur geen constructoren opgeeft is er geen enkel probleem: er worden gewoon overal lege constructoren aangemaakt .

[GiLuX]

ok,
ben er al een beetje uit.

punt een van die subclass zonder constructor die een class extend met lege constructor, daar werd de superclass constructor niet aangeroepen.

zoals als onno reeds terecht opmerkte,
daar stond nog 'void' voor (vanwege cut en peest acties mijnerzijde).

heb ik weggehaald en dan werkt het idd wel.
is dat een feature of een bug, of heeft de compiler zoiets van:"wil je een constructor void? prima, jouw feestje!"

wat betreft dat dat boek zegt dat als je superclass geen (lege) constructor heeft bedoelen ze waarschijnlijk je base superclass, in dit geval dus Object.

ik neem aan dat ze dat bedoelen maar staat er niet zo direct...

tnx all

[mbravenboer]

GiLuX: is dat een feature of een bug, of heeft de compiler zoiets van:"wil je een constructor void? prima, jouw feestje!"

Nou ja, in dat geval is het dus gewoon een methode. Het is niet verboden om een methode met een hoofdletter te schrijven en zelfs met dezelfde naam als de klasse. Een compiler waarschuwing zou hier overigens niet verkeerd zijn .