Abstrakte Klasse: Konstruktor vs init()

[-frank]

ich habe eine abstrakte klasse, die von einigen anderen erweitert wird. einige initialisierungsaufgaben müssen im konstruktor der erweiternden klassen vorgenommen werden, anderes kann in der abstrakten klasse gemacht werden. nun ist es so, dass ich - auch wenn ich den code derzeit nur für mich schreibe - nicht will, dass man irrtümlich die initialiserungsmethode der abstrakten klasse nicht aufruft. folglich würde ich die initialisierung in den konstruktor packen. dann aber muss in der ersten zeile des konstruktors der erweiternden klassen ein super(...) stehen. und das will ich nicht, da ich zuvor vielleicht noch etwas anderes machen möchte.
wäre es das beste eine init(..)-methode zu verwenden, die ein init-flag auf true setzt und diesen in anderen methoden zu überprüfen? (somit könnte ich garantierten, dass die init methode aufgerufen wurde, aber ich will auch nicht in jede methode eine if(init==true) abfrage einbauen...)
also würdet ihr vielleicht doch nur in der JavaDoc darauf hinweisen, dass es die init-methode gibt und man sie aufrufen soll/muss/kann?

 

[Wildcard]

Der Konstruktor muss eh zuerst aufgerufen werden, und damit auch super(...).
Wo möchtest du den Code den du gerne vorher ausführen möchtest denn unterbringen?
Wie du siehst geht es nicht, also kannst du deine Initialisierung genauso nach dem super(...) im Konstruktor machen, oder vom Konstruktor aus eine init Methode aufrufen.

 

[-frank]

Wo möchtest du den Code den du gerne vorher ausführen möchtest denn unterbringen?

naja, ich habe (wie du ja schon weißt, weil du mir nicht zum ersten mal hilfst - danke!) eine Klasse AbstractA. Diese wird erweitert von A1..A6. Nun hat jedes AbstractA ein, sagen wir, ObjectA. Dieses soll im Konstruktor übergeben werden. in A1 ist es aber ein ObjectA1, in A2 ein Objekt A2.
wenn ich nun zum beispiel im A1-Konstruktor einen String übergeben bekomme, mit dem ich ObjectA1 initialisiere, dann könnte der Code so aussehen:

public A1(String someString) {
if (!checkStringIsValid(someString) {
throw new exception...
}

Object objA1 = new ObjectA1(someString);

super(objA1);

}

die Konstruktion von objA1 muss nicht zwingend in einer eigenen Zeile sein, von daher könnte ich
auch

super(new ObjectA1(someString));

schreiben, aber bei langen Konstruktoren wird der Code dadurch nur unleserlich.
und den Stringcheck könnte ich später machen, aber rein intuitiv würde ich lieber zuerst meine werte auf gültigkeit überprüfen und dann die initialisierung vornehmen.

 

[Wildcard]

Das geht aber nicht.
Die erste Anweisung in einem Konstruktor ist immer der Aufruf eines super-Konstruktors (mit Ausnahme von Object natürlich)

 

[schalentier]

Mach alles was irgendwas initialisiert in die init Methode und anstatt super(...) ruf init(..) auf (bzw ruf init(..) im Konstruktor von AbstractA auf).

 

[-frank]

Das geht aber nicht.
Die erste Anweisung in einem Konstruktor ist immer der Aufruf eines super-Konstruktors (mit Ausnahme von Object natürlich)

--> wenn der konstruktor nicht aufwändig ist, mache den gültigkeitscheck einfach erst nachher (ist ja nicht so schlimm dann). wenn die initialisierung sehr aufwändig ist, initialisiere ich nicht im konstruktor sondern in einer init() methode. dass man diese aus der erweiternden klasse aufrufen muss, schreibe ich dann einfach in die Dokumentation. ist das eine akzeptable strategie?

 

[Wildcard]

Du kannst eine evtl. init Methode erst aufrufen wenn du ein Objekt der Klasse hast.
Um ein Objekt zu bekommen muss der Konstruktor durchlaufen werden.
Wenn der Konstruktor durchlaufen wird, wird auf den super Konstruktor verweisen.
Fällt dir was auf?

 

[-frank]

Mach alles was irgendwas initialisiert in die init Methode und anstatt super(...) ruf init(..) auf (bzw ruf init(..) im Konstruktor von AbstractA auf).

das mit init funktioniert eigentlich eh sehr gut. mir gehts wie gesagt darum, wie ich andere Entwickler am besten darauf hinweise kann, dass sie diese init(..) methode aufrufen müssen. da wäre der konstruktor halt optimal gewesen, weils einem da schon der compiler sagt und nicht nur die doku.

 

[-frank]

Du kannst eine evtl. init Methode erst aufrufen wenn du ein Objekt der Klasse hast.
Um ein Objekt zu bekommen muss der Konstruktor durchlaufen werden.
Wenn der Konstruktor durchlaufen wird, wird auf den super Konstruktor verweisen.
Fällt dir was auf?

dass alle konstruktoren bis rauf zu Object() aufgerufen werden müssen und natürlich durch Object() überhaupt erst mal ein Objekt erzeugt werden muss, ist mir schon klar. aber gerade weil das so ist, wollte ich eben gerne das objekt durch den konstruktor in einen initilaisierten zustand bringen, also in einen, in dem man das Objekt verwenden kann (und dass man nicht nachher noch init(..) aufrufen muss). allerdings ist die klasse ja abstrakt und das beudetet, dass dies für Benutzer des Objekts eh gilt, denn die rufen ja nur den konstruktor von A1 auf (von welchem aus AbstractA.init(..) aufgerufen wird). und leuten, die AbstractA erweitern, kann man wohl zumuten, dass sie die Doku von AbstractA lesen...

 

[Wildcard]

Ich verstehe dein Problem nicht.
Jede init Methode von der du möchtest das sie nach der Objekterzeugung aufgerufen wird, wird in jedem Fall nach dem Konstruktor aufgerufen. Demzufolge kannst du das genausogut selbst im Konstruktor erledigen.

 

[Ariol]

Seh ich das richtig, das du eine Klasse A mit einem Object a hast und mehrer unterklassen A1 bis Ax mit Objecten a1 bis ax?

Sind die Objecte wiederum Klassen? ( Object objA1 = new ObjectA1(someString); )

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

du könntest in der Klasse A weiter Konstruktoren einbauen und dann z.B so aufrufen.

ObjectA a;

public A ()
{
    this("a");
}

public A (String aname)
{
      a = new ObjectA(aname);
}

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

ObjectA1 a1;

public A1 (String aname)
{
      super("aname");
      try
      {
             a1 = (ObjectA1)super.a; // Das super muss nicht sein
      }
      catch (ClassCastException cce){} 
}

 

[-frank]

Ich verstehe dein Problem nicht.
Jede init Methode von der du möchtest das sie nach der Objekterzeugung aufgerufen wird, wird in jedem Fall nach dem Konstruktor aufgerufen. Demzufolge kannst du das genausogut selbst im Konstruktor erledigen.

wenn ich AbstractA.init() im konstruktor von AbstractA aufrufe, hab ich wieder das Problem, dass die fehlerbehandlung von A1 erst nach Abstract.init() erfolgt (und wenn init() aufwändig ist, möchte ich zuerst die fehlerbehandlung).
wenn ich init() im konstruktor von A1 aufrufe, funktioniert alles wunderbar, ABER dies muss natürlich auch im konstruktor von A2..A6 erfolgen und eventuell auch in A7, das jemand anderes schreibt. (und der könnte das init() halt vergessen. eigentlich gings mir nur darum)

 

[-frank]

@Ariol: das wirft immer eine classcastexception, da es sich ja nicht um einen ObjectA1 handelt (sondern nur um ein ObjectA).

ein anderer ansatz wäre, das Objekt in A1..A6 zu speichern. dort hätte es immer den richtigen typ. und in AbstractA definiere ich nur eine Methode protected abstract getObjectA(). (löst aber mein Problem nicht wirklich, da getObjectA() dann null liefert bis es in A1 gesetzt wird. das kann aber frühestens im Konstruktor passieren.

 

[-frank]

ich werde es zwar so nicht machen, weils mir zu extrem scheint, aber eigentlich könnte man es so lösen:

	/**
	 * Ruft AbstractA.init() auf. (fuer mehr info siehe ...)
	 */
	protected abstract void callInit();

auf diese weise MUSS der entwickler die methode implementieren (und kann die init() method enicht irrtümlich übersehen).