Java-Reihenfolge der Initialisierung und Instanziierung

Bin ich versucht, Stück zusammen den Prozess der Initialisierung und Instanzierung in der JVM, aber die JLS ist ein wenig stumpf auf ein paar Einzelheiten, also wenn jemand was dagegen hätte, Aufräumarbeiten einige details, es wäre zu schätzen. Dies ist, was ich in der Lage gewesen, um herauszufinden, so weit.

Initialisierung

Rekursiv Initialisiert static final-Variablen der Klasse und deren Schnittstellen, sind compile-Zeit-Konstanten.
Wieder aus der Rekursion-Verarbeitung statische Blöcke und statische Felder in textueller Reihenfolge.

Instanziierung

Rekursiv Initialisiert Letzte Instanz-Variablen der Klasse sind, die compile-Zeit-Konstanten.
Wieder aus der Rekursion-Verarbeitung von nicht-statische Blöcke und Instanz-Felder in textlicher voranstellen, um Sie in die Konstruktoren, wie es gibt.

Okay, nun also die Fragen stellen.

sind Schnittstellen verarbeitet in der Reihenfolge der Deklaration?
sind Schnittstellen verarbeitet in einem separaten recursive-stack?
a) wenn ja, Schnittstellen verarbeitet vor oder nach der Oberklassen?

b) wenn ja, bin ich richtig in der Aufzucht, dass der eine oder andere (Interface oder Superklasse) erhält seine nicht-compile-Zeit-Konstante Felder initialisiert, bevor die anderen compile-Zeit-Konstanten.
Welche Rolle spielt die Aufrufe der standardmäßige super () - Konstruktor spielen in diesem Prozess?
Täusche ich mich in irgendeiner meiner Aussagen?
Fehlen mir andere wichtige details?

Schnittstellen haben nichts damit zu initialisieren. Es sei denn, Sie verwenden das Wort in einer anderen Weise als ich es gewohnt bin.
Schnittstellen public static final Felder. Wenn diese Felder sind Objekte mit einer Initialisierung (z.B. public static final ArrayList<String> someStrings = new ArrayList<>();) dann wäre ein Teil der Initialisierung.

InformationsquelleAutor user3056052 | 2014-04-15

java

43

Ist es wichtig zu unterscheiden, zwischen der Initialisierung der Klasse und Initialisierung eines Objekts.

Klasse Initialisierung

Einer Klasse oder Schnittstelle ist initialisiert auf ersten Zugriff, durch die Zuordnung der compile-Zeit-Konstante Felder, dann rekursiv die Initialisierung der Oberklasse (falls noch nicht initialisiert), dann die Verarbeitung der statischen Initialisierungen (die die Initialisierungen für die statischen Felder, die keine compile-Zeit-Konstanten).

Als Sie bemerkt haben, Initialisierung einer Klasse nicht von sich aus auslösen die Initialisierung der Schnittstellen, die Sie implementiert. Schnittstellen sind daher initialisiert, wenn Sie zum ersten mal aufgerufen wird, in der Regel durch das Lesen eines Feldes, das nicht zu einem compile-Zeit-Konstante. Dieser Zugang kann auftreten, während der Auswertung einer Initialisierung, wodurch eine rekursive Initialisierung.

Es ist auch erwähnenswert, dass die Initialisierung wird nicht ausgelöst, durch den Zugriff auf Felder, die compile-Zeit-Konstanten, wie diese bewertet werden bei compile-Zeit:

Einen Verweis auf ein Feld, das eine Konstante variable (§4.12.4) aufgelöst werden muss zur compile-Zeit der Wert V gekennzeichnet durch die Konstante variable in der Initialisierung.

Wenn solch ein Feld ist statisch, dann wird kein Verweis auf das Feld sollte vorhanden sein, den code in eine binäre Datei, einschließlich der Klasse oder Schnittstelle, die deklariert das Feld. Ein solches Feld muss immer initialisiert wurden (§12.4.2); der default-Initialwert für das Feld (wenn anders als V) darf nie beobachtet werden.

Wenn ein solches Feld nicht statisch ist, dann wird kein Verweis auf das Feld sollte vorhanden sein, den code in eine binäre Datei, außer in der Klasse, die das Feld. (Es wird ein Klasse sondern ein interface, da ein interface nur statische Felder.) Die Klasse sollte code, um das Feld festzulegen, die den Wert von V während der instanzerstellung (§12.5).

Objekt-Initialisierung

Ein Objekt initialisiert Wann immer ein neues Objekt erstellt wird, in der Regel durch Auswertung einer Klasse-Instanz-Erstellung-Ausdruck. Dies geht wie folgt:
1. Ordnen Sie die Argumente für den Konstruktor neu erstellte parameter-Variablen, die für diese Konstruktor-Aufruf.
2. Wenn dieser Konstruktor beginnt mit einem expliziten Konstruktor-Aufruf (§8.8.7.1) an einen anderen Konstruktor der gleichen Klasse (mit diesem), dann bewerten Sie die Argumente und den Prozess, der Konstruktor-Aufruf rekursiv mit den gleichen fünf Schritte. Wenn das Konstruktor-Aufruf abgeschlossen ist abrupt, dann ist diese Prozedur abgeschlossen abrupt aus dem gleichen Grund; andernfalls weiter mit Schritt 5.
3. Dieser Konstruktor beginnt nicht mit einem expliziten Konstruktor-Aufruf eines anderen Konstruktors der gleichen Klasse (mit diesem). Wenn dieser Konstruktor für eine Klasse, andere als Objekt, dann wird dieser Konstruktor wird beginnen mit einer expliziten oder impliziten Aufruf einer superclass-Konstruktor (super). Bewerten Sie die Argumente und den Prozess, der superclass-Konstruktor-Aufruf rekursiv mit den gleichen fünf Schritte. Wenn das Konstruktor-Aufruf abgeschlossen ist abrupt, dann ist diese Prozedur abgeschlossen abrupt aus dem gleichen Grund. Ansonsten weiter mit Schritt 4.
4. Ausführung der Instanz-Initialisierungen und Instanz-Variablen-Initialisierungen für diese Klasse, die die Zuordnung der Werte der Instanz-Variablen-Initialisierungen der entsprechenden Instanz-Variablen, in die von-Links-nach-rechts Reihenfolge, in der Sie angezeigt werden textlich in den source-code für die Klasse. Wenn die Ausführung eine dieser Initialisierungen zu einer Ausnahme führt, dann keine weiteren Initialisierungen verarbeitet werden und dieses Verfahren schließt abrupt mit derselben Ausnahme. Andernfalls fahren Sie mit Schritt 5 Fort.
5. Ausführen, der rest des Körpers von dieser Konstruktor. Wenn die Ausführung abgeschlossen ist abrupt, dann ist diese Prozedur abgeschlossen abrupt aus dem gleichen Grund. Ansonsten, ist dieses Verfahren normalerweise abgeschlossen.
Wie wir sehen können, in Schritt 3, das Vorhandensein einer expliziten Aufruf des super-Konstruktors einfach verpasst, die super-Klasse-Konstruktor aufgerufen wird.

InformationsquelleAutor meriton

Folgenden ein Beispiel, drucken Sie die Reihenfolge der einzelnen Schritte bei der Objekterstellung.

InstanceCreateStepTest.java:

import javax.annotation.PostConstruct;

/**
 * Test steps of instance creation.
 * 
 * @author eric
 * @date Jan 7, 2018 3:31:12 AM
 */
public class InstanceCreateStepTest {
    public static void main(String[] args) {
        new Sub().hello();
        System.out.printf("%s\n", "------------");
        new Sub().hello();
    }
}

class Base {
    static {
        System.out.printf("%s - %s - %s\n", "base", "static", "block");
    }
    {
        System.out.printf("%s - %s - %s\n", "base", "instance", "block");
    }

    public Base() {
        System.out.printf("%s - %s\n", "base", "constructor");
    }

    @PostConstruct
    public void init() {
        System.out.printf("%s - %s\n", "base", "PostConstruct");
    }

    public void hello() {
        System.out.printf("%s - %s\n", "base", "method");
    }
}

class Sub extends Base {
    static {
        System.out.printf("%s - %s - %s\n", "sub", "static", "block");
    }
    {
        System.out.printf("%s - %s - %s\n", "sub", "instance", "block");
    }

    public Sub() {
        System.out.printf("%s - %s\n", "sub", "constructor");
    }

    @PostConstruct
    public void init() {
        System.out.printf("%s - %s\n", "sub", "PostConstruct");
    }

    @Override
    public void hello() {
        //super.hello();
        System.out.printf("%s - %s\n", "sub", "method");
    }
}

Ausführung:

Nur aufrufen der main-Methode, und dann überprüfen Sie die Ausgabe.

Tipps:

Das Verfahren gekennzeichnet ist durch die @PostConstruct nicht geltend gemacht werden, es sei denn, Sie rufen es in einige Behälter, wie Spring-boot, da es von denen abhängt, die Container zu implementieren annotation wie @PostConstruct.

InformationsquelleAutor Eric Wang

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.