Inheritance van een constructor

[Verwijderd]

Ik heb een klasse gemaakt met daarin een constructor die er als volgt uit ziet:
public Persoon(String naam, String adres, String woonplaats, String postcode) {
this.naam = naam;
this.adres = adres;
this.woonplaats = woonplaats;
this.postcode = postcode;
}

Dit is de constructor van de Superklasse en nu heb ik hiervan een subklasse gemaakt; Kok genaamd met de volgende constructor:

public Kok(String naam, String adres, String woonplaats, String postcode, Stringboolean kookboek, int aantalkoks, double salaris) {
this.kookboek = kookboek;
this.salaris = salaris;
this.aantalkoks = aantalkoks;
}

Maar nu wil ik dus dat Kok de constructor waardes van de Persoon constructor overneemt. Dus als ik een Kok object aanmaak dat ook de naam, woonplaats, postcode, en het adres aangemaakt worden. Ik dacht dat dit allemaal automatisch ging als je een klasse "extend" maar dit werkt dus blijkbaar niet zo met de constructor. Hoe krijg ik nu dus gewoon een goede constructor zodat als ik een kok aanmaak al deze gegevens in 1 keer heb.

[Verwijderd]

Oh ja en het gaat hier om JAVA.

[BastiaanN]

http://java.sun.com/docs/...ial/java/IandI/super.html

[RobIII]

Waar hoort mijn topic?
SEA >> PRG

Verder: als je code post, gebruik dan a.u.b. code tags.

[Verwijderd]

BastiaanN schreef op zondag 20 september 2009 @ 13:18:
http://java.sun.com/docs/...ial/java/IandI/super.html

Thmx man hier staat het inderdaad erg duidelijk. Maar nu zit ik met nog een probleem. Ik heb nu dus nog een klasse waarbij de waardes van het object in een array gezet worden.

Deze array werkte wel ,maar is nu sinds ik die inheritance constructor toegepast heb, niet meer werkend.
Dit is de code van de array:
public DamascusShoarma() {
bezorgers[0] = new Bezorger("Klaas Jansma", "Gietstraat 34", "Rotterdam", "2345DR", true,1200.00);
bezorgers[1] = new Bezorger("Piet Pietersen", "potstraat 43", "Rotterdam", "2356FR", true, 1250.00);
koks[0] = new Kok("Pieter Janssen", "Gietstraat 34", "Utrecht", "2234CD", true, 1800.00);
koks[1] = new Kok("Peter Jansen", "Kietstraat 19", "Utrecht", "2234CD", true, 1850.00);
}
De constructor moet dus die gegevens van de constructor van Kok overnemen. Dat deed ie eerst wel, maar nu dus niet meer. Hoe kan ik dit oplossen. Of moet ik iets van "new Kok, Persoon" schrijven ofzo?

ps: sorry dat de boel niet tussen tags staat maar ik weet dus niet hoe ik dat doe.

[Voutloos]

[code=java]
String uitleg = new String("Schrijf hier je Java code :P ");
[/code]

geeft:

Java:

String uitleg = new String("Schrijf hier je Java code :P ");

[ Voor 32% gewijzigd door Voutloos op 20-09-2009 14:34 ]

[Nick The Heazk]

Verwijderd schreef op zondag 20 september 2009 @ 14:28:
Deze array werkte wel ,maar is nu sinds ik die inheritance constructor toegepast heb, niet meer werkend.
Dit is de code van de array:
[..]
De constructor moet dus die gegevens van de constructor van Kok overnemen. Dat deed ie eerst wel, maar nu dus niet meer. Hoe kan ik dit oplossen. Of moet ik iets van "new Kok, Persoon" schrijven ofzo?

Wat zegt de compiler? Compileert hij?

Het is overigens handiger voor ons indien je alle relevante code post. Nu zou zowat alles fout kunnen zijn. In dit specifieke geval zit deeen fout trouwens in de stukjes code die je gepost hebt, maar je leert er meer uit door zelf de fout te zoeken en te vinden.

[ Voor 21% gewijzigd door Nick The Heazk op 20-09-2009 14:54 ]

[DEiE]

waarschijnlijk heb je je array private gemaakt. Als je je variabelen wilt gebruiken in een extended class, moet je ze protected maken

quote: http://en.wikipedia.org/w..._hiding_and_encapsulation

A common set of access specifiers that many object-oriented languages support is:

• Private (or class-private) restricts the access to the class itself. Only methods that are part of the same class can access private members.
• Protected (or class-protected) allows the class itself and all its subclasses to access the member.
• Public means that any code can access the member by its name.

[ Voor 67% gewijzigd door DEiE op 20-09-2009 15:09 ]

[MLM]

ik ga er van uit dat jij zoekt naar de manier om de base-constructor aan te roepen. Nu heb ik echt 0 verstand van Java, maar in C# (wat er wel iets op lijkt) doe je iets als dit:

C#:

class baseclass
{
  string a;
  string b;

  protected_of_public baseclass(string a, string b)
  {
    this.a = a;
    this.b = b;
  }
};

class derivedclass : public baseclass
{
  string c;

  public derivedclass(string a, string b, string c) : base(a, b) //hier is de magic
  {
    this.c = c;    
  }
};

Ik neem aan dat Java een soortgelijke optie heeft

[NMe]

Verwijderd schreef op zondag 20 september 2009 @ 14:28:
[...]

ps: sorry dat de boel niet tussen tags staat maar ik weet dus niet hoe ik dat doe.

Anders klik je gewoon even op de link die RobIII er zo netjes bij geeft? En anders: Hoe post je code? / Hoe gebruik je de code tag?

En wat je oplossing betreft...

Java:

 public Kok(String naam, String adres, String woonplaats, String postcode, Stringboolean kookboek, int aantalkoks, double salaris) {
         this.kookboek = kookboek;
         this.salaris = salaris;
         this.aantalkoks = aantalkoks;
         super();  // wel even met de juiste parameters doen, maar nu heb je in elk geval een houvast ;)
     }

[ Voor 36% gewijzigd door NMe op 20-09-2009 15:40 ]

[Robtimus]

Maar dan moet de super() als allereerste statement in de constructor.

[YopY]

Of je pakt je boek / cursus er even bij en begint te lezen bij hoofdstuk 1.

[NMe]

IceManX schreef op zondag 20 september 2009 @ 15:59:
Maar dan moet de super() als allereerste statement in de constructor.

Dat maakt in dit geval niet uit, toch? Of heeft Java daar restricties voor?

[Remus]

NMe schreef op zondag 20 september 2009 @ 18:30:
[...]

Dat maakt in dit geval niet uit, toch? Of heeft Java daar restricties voor?

Bij Java moet de constructor aanroep de eerste aanroep zijn (indien de aanroep afwezig is wordt een impliciete call naar de default (of parameterloze) constructor van de superclass toegevoegd). De redenen hiervoor hebben als ik mij goed herinner oa te maken met visibility en het Java geheugenmodel.

[NMe]

Remus schreef op zondag 20 september 2009 @ 18:34:
[...]

Bij Java moet de constructor aanroep de eerste aanroep zijn (indien de aanroep afwezig is wordt een impliciete call naar de default (of parameterloze) constructor van de superclass toegevoegd). De redenen hiervoor hebben als ik mij goed herinner oa te maken met visibility en het Java geheugenmodel.

Hmm, dat wist ik dan weer niet. Maar goed, ik ben dan ook geen Java-programmeur.

[Verwijderd]

Trouwens het werkt nu allemaal! Ik had bij die koks een variabel te veel in de constructor geplaatst.

[Niemand_Anders]

Remus schreef op zondag 20 september 2009 @ 18:34:
[...]

Bij Java moet de constructor aanroep de eerste aanroep zijn (indien de aanroep afwezig is wordt een impliciete call naar de default (of parameterloze) constructor van de superclass toegevoegd). De redenen hiervoor hebben als ik mij goed herinner oa te maken met visibility en het Java geheugenmodel.

Ik zou eigenlijk zeggen dat de compiler zoiets zou moeten afvangen. De compiler weet toch wanneer hij een constructor aan het compileren is, zou deze dan als default super() kunnen aanhouden totdat in de code een andere super met argumenten wordt aangeroepen. In c# komt de super (base in c#) direct achter de constructor zelf. Ik vermoed dat java de super om een ander reden op regel 1 van de constructor wilt hebben. Namelijk om te voorkomen dat de code twee supers achter elkaar aanroept.

Java:

public Kok()
{
   super("hello");
   super("hello", "world");
}

Ik heb al zeer lang (sinds 2000) niets meer gedaan met java, maar bovenstaand zal zeer waarschijnlijk een compiler error opleveren. Echter tweemaal achter elkaar een return of throw statement plaatsen geeft geen compiler error, wel een waarschuwing dat er onuitvoerbare code is gevonden.

Maar laat ik er geen vi vs emacs discussie van maken ;-)

[whoami]

Als een taal vereist dat een base-constructor call als eerste of als laatste uitgevoerd moet worden, dan vind ik een constructie ala C# toch beter. Het is duidelijker en je hebt gewoon geen kans om te missen / twijfelen.

code:

public Derived ("melp", "blaat") : base ("blaat") {}

[Haan]

whoami schreef op maandag 21 september 2009 @ 09:46:
Als een taal vereist dat een base-constructor call als eerste of als laatste uitgevoerd moet worden, dan vind ik een constructie ala C# toch beter. Het is duidelijker en je hebt gewoon geen kans om te missen / twijfelen.

code:

public Derived ("melp", "blaat") : base ("blaat") {}

Doe het dan goed

C#:

public Derived(string melp, string blaat) : base (blaat) { } 

[whoami]

Jaja, tijd voor koffie.

[Remus]

Niemand_Anders schreef op maandag 21 september 2009 @ 09:38:
[...]

Ik zou eigenlijk zeggen dat de compiler zoiets zou moeten afvangen. De compiler weet toch wanneer hij een constructor aan het compileren is, zou deze dan als default super() kunnen aanhouden totdat in de code een andere super met argumenten wordt aangeroepen. In c# komt de super (base in c#) direct achter de constructor zelf. Ik vermoed dat java de super om een ander reden op regel 1 van de constructor wilt hebben. Namelijk om te voorkomen dat de code twee supers achter elkaar aanroept.

Zo werkt het dan dus ook. Je hoeft super() niet aan te roepen (als het om de parameterloze constructor gaat); al geven sommige ontwikkelaars er wel de voorkeur aan om het expliciet te doen. De compiler zal die call zelf toegeven. Wil je een andere constructor, dan moet je dat zelf wel expliciet doen (op de eerste regel).

Ik ben het met je eens dat de C# oplossing mooier is. Zoiets heet voortschrijdend inzicht (taal designers zitten ook niet stil), dan wel andere keuzes (het is natuurlijk extra syntactic sugar).

[PrisonerOfPain]

Niemand_Anders schreef op maandag 21 september 2009 @ 09:38:
Ik vermoed dat java de super om een ander reden op regel 1 van de constructor wilt hebben. Namelijk om te voorkomen dat de code twee supers achter elkaar aanroept.

Of om te voorkomen dat je methods aan gaat roepen op een ongeinitialiseerd object.

[MLM]

Ik neem aan dat de compiler forceert dat je eerst je base-classes construct, net als in C++ en C#...
Zoals het hoort(tm)

[PrisonerOfPain]

MLM schreef op maandag 21 september 2009 @ 21:47:
Ik neem aan dat de compiler forceert dat je eerst je base-classes construct, net als in C++ en C#...
Zoals het hoort(tm)

Zoals ik zei, dat is waarschijnlijk dus de rede dat de taal je forceert super() aan het begin van je constructor.

[.oisyn]

Wat natuurlijk een ontzettend arbitraire regel is. Je mag ook gewoon een method van je huidige class aanroepen voordat je je variabelen hebt geïnitialiseerd. En het kan voorkomen dat je aan de constructor van de base class een parameter wilt geven die je nog moet maken (bijvoorbeeld een gevulde ArrayList), maar dat mag je dan ook niet doen voor de super() aanroep (dan moet je een static method maken die zoiets returnt).
Maar als ik dit doe:

Java:

class Base
{
    Base(int i) { }
}

class Test extends Base
{
    Test()
    {
        super(init());
    }   
    
    int init() { return 3; }
}

krijg ik deze error:

cannot reference this before supertype constructor has been called

Dus blijkbaar heeft hij (logisch ook) genoeg kennis van de code om te zien dat jij 'this' gebruikt voor de call naar de baseclass. Waarom is die regel dat het per se het eerste statement moet zijn dan überhaupt?

[Remus]

.oisyn schreef op maandag 21 september 2009 @ 23:20:
Wat natuurlijk een ontzettend arbitraire regel is. Je mag ook gewoon een method van je huidige class aanroepen voordat je je variabelen hebt geïnitialiseerd. En het kan voorkomen dat je aan de constructor van de base class een parameter wilt geven die je nog moet maken (bijvoorbeeld een gevulde ArrayList), maar dat mag je dan ook niet doen voor de super() aanroep (dan moet je een static method maken die zoiets returnt).
Maar als ik dit doe:

Java:

class Base
{
    Base(int i) { }
}

class Test extends Base
{
    Test()
    {
        super(init());
    }   
    
    int init() { return 3; }
}

krijg ik deze error:

cannot reference this before supertype constructor has been called

Dus blijkbaar heeft hij (logisch ook) genoeg kennis van de code om te zien dat jij 'this' gebruikt voor de call naar de baseclass. Waarom is die regel dat het per se het eerste statement moet zijn dan überhaupt?

Die regel is expliciet opgenomen in de Java Language Specification paragraaf 8.8.7.1:

An explicit constructor invocation statement in a constructor body may not refer to any instance variables or instance methods declared in this class or any superclass, or use this or super in any expression; otherwise, a compile-time error occurs.

De reden dat de constructor als eerste moet, heeft te maken met het feit dat instance (en variable) initializers (pas) worden aangeroepen als de constructor van de superclass voltooid is. Als dat nog niet gebeurd is, dan kan je dus in je constructor voor onverwachte problemen komen te staan.

Finally, if the constructor invocation statement is a superclass constructor invocation and the constructor invocation statement completes normally, then all instance variable initializers of C and all instance initializers of C are executed. If an instance initializer or instance variable initializer I textually precedes another instance initializer or instance variable initializer J, then I is executed before J. This action is performed regardless of whether the superclass constructor invocation actually appears as an explicit constructor invocation statement or is provided automatically. An alternate constructor invocation does not perform this additional implicit action.

[.oisyn]

Lieve schat, dat hoef je mij niet te vertellen . De strekking van mijn post was dat dat stukje 8.8.7.1 wat je daar quote in feite alles al afdekt als je 'm iets aanpast. Het feit dat de ctor per se de eerste statement moet zijn is dus nogal loos, gezien het feit dat het geheel reasonable is dat je eerst wat met lokale variabelen doet voordat je de base ctor aanroept. De kern van het geheel is dat je wilt afschermen dat je object state referenced voordat je helemaal geconstruct bent, maar om dat te bereiken hoeft de base ctor aanroep nog niet per se het eerste statement te zijn. De compiler hoeft alleen maar te checken of je tussen het begin van de ctor en de aanroep van de base ctor 'this' referenced. Ergo, de regel dat het het eerste statement moet zijn is nogal arbitrair.

[ Voor 41% gewijzigd door .oisyn op 22-09-2009 21:15 ]