Wie unterscheidet sich ein Instanzinitialisierer von einem Konstruktor?

Mit anderen Worten, warum benötigen Sie einen Instanzinitialisierer? Welchen Unterschied oder Vorteil haben Sie beim Schreiben eines Instanzinitialisierers gegenüber einem Konstruktor?

Dies scheint es gut zu erklären:

Instanzinitialisierer sind eine nützliche Alternative zu Instanzvariableninitialisierern, wenn:

• Der Initialisierungscode muss Ausnahmen abfangen, oder

• Führen Sie ausgefallene Berechnungen durch, die mit einem Instanzvariablen-Initialisierer nicht ausgedrückt werden können. Sie können solchen Code natürlich immer in Konstruktoren schreiben.

In einer Klasse mit mehreren Konstruktoren müssten Sie jedoch den Code in jedem Konstruktor wiederholen. Mit einem Instanzinitialisierer können Sie den Code nur einmal schreiben. Er wird ausgeführt, unabhängig davon, mit welchem ​​Konstruktor das Objekt erstellt wird. Instanzinitialisierer sind auch in anonymen inneren Klassen nützlich, die überhaupt keine Konstruktoren deklarieren können.

Von: JavaWorld- Objektinitialisierung in Java .

In Bezug auf den Objektlebenszyklus gibt es keinen Unterschied. Beide werden zur Konstruktionszeit aufgerufen, und logischerweise kann der Initialisierungsblock als Teil der Konstruktion betrachtet werden.

Semantisch gesehen ist ein Initialisierer aus mehreren Gründen ein gutes Werkzeug:

Der Initialisierer kann die Lesbarkeit des Codes verbessern, indem die Initialisierungslogik neben der zu initialisierenden Variablen bleibt:

   public class Universe {
       public int theAnswer;
       {
         int SIX = 6;
         int NINE = 7;
         theAnswer = SIX * NINE;
       }

       // a bunch of other vars
   }

vs.

   public class Universe {
       public int theAnswer;

       // a bunch of other vars

       public Universe() {
         int SIX = 6;
         int NINE = 7;
         theAnswer = SIX * NINE;

         // other constructor logic
       }
   }

Initialisierer werden unabhängig davon aufgerufen, welcher Konstruktor verwendet wird.

Initialisierer können in anonymen inneren Klassen verwendet werden, Konstruktoren nicht.

Wenn Sie viele Konstruktoren haben und möchten, dass für jeden Konstruktor ein allgemeiner Code ausgeführt wird, können Sie den Instanzinitialisierer verwenden. Dies wird für alle Konstruktoren aufgerufen.

Ich würde das Idiom des Instanzinitialisierers im Allgemeinen vermeiden - der einzige wirkliche Vorteil, den es gegenüber variablen Initialisierern bietet, ist die Ausnahmebehandlung.

Und da eine init-Methode (vom Konstruktor aus aufrufbar) auch die Ausnahmebehandlung durchführen und den Konstruktor-Setup-Code zentralisieren kann, aber den Vorteil hat, dass sie mit Konstruktorparameterwerten arbeiten kann, würde ich sagen, dass der Instanzinitialisierer redundant ist und daher redundant sein muss vermieden.

Der wahre Vorteil von Instanzinitialisierern gegenüber Konstruktoren zeigt sich, wenn wir eine anonyme innere Klasse verwenden .

Anonyme innere Klassen können keinen Konstruktor haben (da sie anonym sind) , daher eignen sie sich ziemlich gut für beispielsweise Initialisierer .

Wenn wir zum Zeitpunkt der Objekterstellung die Initialisierung von Instanzvariablen durchführen möchten, sollten wir uns für den Konstruktor entscheiden, abgesehen von der Initialisierungsaktivität, wenn wir zum Zeitpunkt der Objekterstellung eine Aktivität ausführen möchten, sollten wir uns für den Instanzblock entscheiden.

Wir können den Konstruktor nicht durch den Instanzblock ersetzen, da der Konstruktor Argumente annehmen kann, der Instanzblock jedoch keine Argumente annehmen kann.

Wir können den Instanzblock nicht durch den Konstruktor ersetzen, da eine Klasse mehr als einen Konstruktor enthalten kann. Wenn wir den Instanzblock durch einen Konstruktor ersetzen möchten, müssen wir in jedem Konstruktor einen Instanzblockcode schreiben, da wir zur Laufzeit nicht erwarten können, welcher Konstruktor aufgerufen wird. Dies erhöht unnötigerweise den doppelten Code.

Beispiel:

class MyClass{

    static int object_count = 0;

    MyClass(){
        object_count++;
    }

    MyClass(int i){

        object_count++;
    }

    void getCount() {

        System.out.println(object_count);
    }

    public static void main(String... args) {
        MyClass one = new MyClass();
        MyClass two = new MyClass(2);
        two.getCount();
    }
}

Ausgabe : 2

class MyClass{

    static int object_count = 0;

    {
        object_count++;
    }

    MyClass(){

    }

    MyClass(int i){     

    }

    void getCount() {

        System.out.println(object_count);
    }

    public static void main(String... args) {
        MyClass one = new MyClass();
        MyClass two = new MyClass(2);
        two.getCount();
    }
}

Ausgabe : 2

Der Initializer ist eine Möglichkeit, Code zwischen Konstruktoren gemeinsam zu nutzen, und macht den Code lesbarer, wenn der Initialisierer mit der Variablendeklaration verwendet wird.

Der Java-Compiler kopiert Initialisierungsblöcke in jeden Konstruktor. Daher kann dieser Ansatz verwendet werden, um einen Codeblock zwischen mehreren Konstruktoren zu teilen. Oracle-Dokumentation