Direkt über den parent-Konstruktor aufrufen, Großeltern

Du das nicht in Java. Ich oft Studenten, die das machen wollen, aber ich habe nie gesehen ein Fall, wo es wirklich das ist, was Sie tun wollte.

Können Sie ein konkretes Beispiel nennen, was es ist, Sie tun möchten und warum (deine Beschreibung ist zu vage), und ich bin sicher, dass eine Lösung erreicht werden kann 🙂

Edit:

Für ein Beispiel aus der Praxis, warum Sie nicht wollen, dies zu tun (normalerweise) wäre eine Hierarchie wie:

Animal (constructor makes the eyes)
  |
Mammal (constructor makes the lungs)
  |
Human (constructor sets the language)

Wenn der Mensch Konstruktor könnte überspringen die Mammal-Konstruktor dann würden Sie wind mit ein Mensch, hat keine Lungen... nicht sehr nützlich.

InformationsquelleAutor TofuBeer

Zwei Kommentare:
Erstens, Sie sind eigentlich nicht zu denken, im Sinne von "springen über' Konstruktoren wie diese.
Zweitens, es wirklich klingt wie Sie brauchen, um zu überdenken Sie Ihre Klasse Beziehungen.

Jeder Zeit finden Sie sich selbst denken "A extends B, außer, dass..." ist eine sehr gute Zeit, um an Sachen weiter. 'Erweitert' impliziert 'ist ein', das ist eine entweder/oder-Beziehung: mit optionalen Verhalten fügt Grauzonen, die beißen, die Sie später auf.

Als die Leute gesagt haben, Sie könnten mehrere Konstruktoren auf ConcreteClass1 zu tun, die Initialisierung benötigen Sie in jedem Fall, vielleicht macht Sie geschützt, so dass Sie nur verwendet werden kann, die von Unterklassen. Aber hier ist eine Frage: was ist, wenn jemand schreiben will CustomizedClass2, die einige (aber nicht alle) Funktionen, die in ConcreteClass1? Fügen Sie einen anderen benutzerdefinierten Konstruktor?

InformationsquelleAutor julian_t

Ist CustomizedData1 eine Unterklasse von ConcreteData1? Wenn dem so ist, dann würde ich vorschlagen einen (evtl. protected) Konstruktor für ConcreteClass1, nimmt in einer ConcreteData1 zu verwenden, anstatt das abrufen Ihrer eigenen während der Initialisierung. Auf diese Weise, CustomizedClass1 Holen kann seinen CustomizedData1 und übergeben es an den Aufruf super. Leider kann dies schwierig sein, oder ziemlich unmöglich, wenn man nicht das abrufen der Daten vor einige interne init.

class ConcreteClass1 extends AbstractClass {
     ConcreteClass1(){
          this(...fetch data as before...);
     }
     ConcreteClass1(ConcreteData1 data){
          myData = data;
          ...
     }
}
class CustomizedClass1 extends ConcreteClass1 {
     CustomizedCLass1(){
          super(new CustomizedData1(...));
          ... 
     }
}

Aber dann CustomizedClass1 muss wahrscheinlich eine Referenz zu den Daten als ein CustomizedData1 nicht nur eine ConcreteData1. Es könnte genau festgelegten übernommenen ConcreteData1 die ganze Zeit, aber das scheint yucky. Aber wenn er speichert seine eigene Referenz, um die Daten, dann ist es notwendig zu halten, werden die Referenzen in sync, wenn Sie nicht endgültig.

InformationsquelleAutor user401321

Einer Weise, die ich kam mit:

class AbstractClass {
     AbstractClass(){ init(); }
     protected init(){ /* useful implementation */ }
}

class ConcreteClass1 extends AbstractClass {
     ConcreteClass1(){ init(); /* useful implementation */ }
}

class CustomizedClass1 extends ConcreteClass1 {
    CustomizedCLass1(){ init(); /* useful implementation */ }
}

In dieser Weise, CustomizedClass1 wird das Verhalten muss es von AbstractClass ohne durch ConcreteClass1 Initialisierungen.

EDIT: Autsch, das funktioniert nicht, weil die Eltern Konstruktoren werden implizit aufgerufen, als einer der Kommentatoren darauf hingewiesen, ich denke, der einfache Weg ist, haben verschiedene Konstruktoren.

InformationsquelleAutor German

Ich denken kann von zwei Fällen, wo man dies möglicherweise tun möchten (eigentlich nicht):

Fall 1, ConcreteClass2 läuft freigegebenen Initialisierung aus der top-Klasse, aber macht dann seine eigene Initialisierung, die verschiedenen Konflikte, als die, die in ConcreteClass1 -> haben eine init () - Methode außer Kraft setzen (anstatt zu versuchen, zu überschreiben ConcreteClass1 Konstruktor).

Fall 2 Sie haben polymorphe Initialisierung eines (oder mehrere) Klasse (das ist eigentlich ein Sonderfall der vorherigen):

public class ConcreteClass1 extend AbstractClass
{
  protected F1 f;

  public ConcreteClass1 () {
    super ();
    this.f = new F1();
  }
}

public ConcreteClass2 extends ConcreteClass1
{
  public ConcreteClass2 () {
    super (); //I'd like to do super.super() instead (no, you don't)
    this.f = new F2(); //We wasted time with new F1 ();
  }
}

In diesem Fall, entweder die Verwendung der init () - Ansatz, oder tun Sie dies:

protected ConcreteClass1 ( F1 f ) {
  super ();
  this.f = f;
}
public ConcreteClass1 () {
  this ( new F1 () );
}

...

public ConcreteClass2 () {
  super ( new F2 () );
}

In anderen Worten, stellen Sie den Grund für den Sprung explizit, implizit Sprung über die Hierarchie ist verboten und für den guten Gründen (siehe andere Antworten.

InformationsquelleAutor zakmck