Standardwerte und Initialisierung in Java

Basierend auf meiner Referenz haben primitive Typen Standardwerte und Objekte sind null. Ich habe einen Code getestet.

public class Main {
    public static void main(String[] args) {
        int a;
        System.out.println(a);
    }
}

Die Linie System.out.println(a);wird ein Fehler sein , zeigt auf der Variable , adie sagt , variable a might not have been initializedwährend in der gegebenen Referenz, integerwird 0als Standardwert. Mit dem unten angegebenen Code wird jedoch tatsächlich gedruckt 0.

public class Main {
    static int a;
    public static void main(String[] args) {
        System.out.println(a);
    }
}

Was könnte möglicherweise mit dem ersten Code schief gehen? Hat Klasse Instanz Variable verhält sich anders als lokale Variablen?

Im ersten Codebeispiel ahandelt es sich um eine mainlokale Methodevariable. Lokale Methodenvariablen müssen vor ihrer Verwendung initialisiert werden.

Im zweiten Codebeispiel ahandelt es sich um eine Klassenmitgliedsvariable, daher wird sie auf den Standardwert initialisiert.

Lesen Sie Ihre Referenz genauer durch :

Standardwerte

Es ist nicht immer erforderlich, einen Wert zuzuweisen, wenn ein Feld deklariert wird. Felder , die deklariert, aber nicht initialisiert sind, 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.

Die folgende Tabelle fasst die Standardwerte für die oben genannten Datentypen zusammen.

. . .

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

Dies sind die Hauptfaktoren:

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

Hinweis 1: Sie müssen die endgültigen Elementvariablen auf JEDEM implementierten Konstruktor initialisieren!

Hinweis 2: Sie müssen die endgültigen Elementvariablen 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 seine Elemente auf Standard gesetzt, unabhängig davon, ob Sie Mitglied oder lokales Array sind.

Ich füge ein Codebeispiel bei und präsentiere die oben genannten Fälle:

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 primitiver Typwerte sind einige Dinge zu beachten.

Sie sind:

1. In einer Methode deklarierte Werte erhalten keinen Standardwert.
2. Als instanziierte Variable oder statische Variable deklarierte Werte werden Standardwerte zugewiesen, die 0 sind.

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 sie 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 dass auf irgendeine Weise Werte zugewiesen werden. 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 Mitglied, 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 Anycode in {}), erhalten Sie keine Werte und bleiben undefiniert, bis sie irgendwie 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 verwendet werden. Daher müssen sie explizit initialisiert werden.

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