Standardwerte und Initialisierung in Java

Lesen Sie genauer Ihre Referenz :

Standardwerte

Es ist nicht immer erforderlich, einen Wert zuzuweisen, wenn ein Feld deklariert wird. Felder , die deklariert, aber nicht initialisiert wurden, werden vom Compiler auf einen angemessenen Standardwert gesetzt. Im Allgemeinen ist dieser Standardwert je nach Datentyp null oder null. Das Verlassen auf solche Standardwerte wird jedoch allgemein als schlechter Programmierstil angesehen.

In der folgenden Tabelle sind die Standardwerte für die oben genannten Datentypen zusammengefasst.

. . .

Lokale Variablen unterscheiden sich geringfügig. Der Compiler weist einer nicht initialisierten lokalen Variablen niemals einen Standardwert zu. Wenn Sie Ihre lokale Variable nicht dort initialisieren können, wo sie deklariert ist, müssen Sie ihr einen Wert zuweisen, bevor Sie sie verwenden. Der Zugriff auf eine nicht initialisierte lokale Variable führt zu einem Fehler bei der Kompilierung.

Dies sind die wichtigsten Faktoren:

1. mitgliedsvariable (Standard OK)
2. statische Variable (Standard OK)
3. letzte Mitgliedsvariable (nicht initialisiert, muss auf Konstruktor gesetzt werden)
4. endgültige statische Variable (nicht initialisiert, muss auf einen statischen Block gesetzt werden {})
5. lokale Variable (nicht initialisiert)

Hinweis 1: Sie müssen endgültige Elementvariablen in JEDEM implementierten Konstruktor initialisieren!

Hinweis 2: Sie müssen die letzten Membervariablen im Block des Konstruktors selbst initialisieren und dürfen keine andere Methode aufrufen, die sie initialisiert. Dies ist beispielsweise NICHT gültig:

private final int memberVar;

public Foo() {
    //invalid initialization of a final member
    init();
}

private void init() {
    memberVar = 10;
}

Hinweis 3: Arrays sind Objekte in Java, auch wenn sie Grundelemente speichern.

Hinweis 4: Wenn Sie ein Array initialisieren, werden alle Elemente auf den Standardwert gesetzt, unabhängig davon, ob es sich um ein Mitglied oder ein lokales Array handelt.

Ich füge ein Codebeispiel an, in dem die oben genannten Fälle dargestellt sind:

public class Foo {
    //static and member variables are initialized to default values

    //primitives
    private int a; //default 0
    private static int b; //default 0

    //objects
    private Object c; //default NULL
    private static Object d; //default NULL

    //arrays (Note: they are objects too, even if they store primitives)
    private int[] e; //default NULL
    private static int[] f; //default NULL

    //what if declared as final?

    //primitives
    private final int g; //not initialized, MUST set in constructor
    private final static int h; //not initialized, MUST set in a static {}

    //objects
    private final Object i; //not initialized, MUST set in constructor
    private final static Object j; //not initialized, MUST set in a static {}

    //arrays
    private final int[] k; //not initialized, MUST set in constructor
    private final static int[] l; //not initialized, MUST set in a static {}

    //initialize final statics
    static {
        h = 5;
        j = new Object();
        l = new int[5]; //elements of l are initialized to 0
    }

    //initialize final member variables
    public Foo() {
        g = 10;
        i = new Object();
        k = new int[10]; //elements of k are initialized to 0
    }

    //A second example constructor
    //you have to initialize final member variables to every constructor!
    public Foo(boolean aBoolean) {
        g = 15;
        i = new Object();
        k = new int[15]; //elements of k are initialized to 0
    }

    public static void main(String[] args) {
        //local variables are not initialized
        int m; //not initialized
        Object n; //not initialized
        int[] o; //not initialized

        //we must initialize them before usage
        m = 20;
        n = new Object();
        o = new int[20]; //elements of o are initialized to 0
    }
}

Beim Deklarieren von primitiven Typwerten sind einige Dinge zu beachten.

Sie sind:

1. In einer Methode deklarierte Werte erhalten keinen Standardwert.
2. Für Werte, die als Instanzvariable oder als statische Variable deklariert wurden, werden Standardwerte mit dem Wert 0 zugewiesen.

Also in deinem Code:

public class Main {
    int instanceVariable;
    static int staticVariable;
    public static void main(String[] args) {
        Main mainInstance = new Main() 
        int localVariable;
        int localVariableTwo = 2;
        System.out.println(mainInstance.instanceVariable);
        System.out.println(staticVariable);
       // System.out.println(localVariable); //will throw compilation error
        System.out.println(localVariableTwo);

    }
}

ja, die Instanzvariable wird auf den Standardwert initialisiert. Für die lokale Variable müssen Sie diese vor der Verwendung initialisieren

public class Main {
      int instaceVariable; // Instance variable will be initalized to default value
    public static void main(String[] args) {
        int localVariable = 0; // Local Variable Need to initalize before use
    }
}

Lokale Variablen erhalten keine Standardwerte. Ihre Anfangswerte sind undefiniert, ohne auf irgendeine Weise Werte zuzuweisen. Bevor Sie lokale Variablen verwenden können, müssen diese initialisiert werden.

Es gibt einen großen Unterschied, wenn Sie eine Variable auf Klassenebene (als Member, dh als Feld) und auf Methodenebene deklarieren.

Wenn Sie ein Feld auf Klassenebene deklarieren, erhalten sie Standardwerte entsprechend ihrem Typ. Wenn Sie eine Variable auf Methodenebene oder als Block deklarieren (dh einen Code innerhalb von {}), erhalten Sie keine Werte und bleiben Sie undefiniert, bis sie auf irgendeine Weise Startwerte erhalten, dh einige ihnen zugewiesene Werte.

Alle Mitgliedsvariablen müssen in den Heap geladen werden, damit sie beim Erstellen einer Klasseninstanz mit Standardwerten initialisiert werden müssen. Bei lokalen Variablen werden sie erst dann in den Heap geladen, wenn sie vor Java 7) im Stack gespeichert wurden. Daher müssen sie explizit initialisiert werden.

In Java gilt die Standardinitialisierung nur für die Instanzvariable des Klassenmitglieds, sie gilt nicht für lokale Variablen.