Valeurs par défaut et Initialisation en Java

Lire plus attentivement votre référence:

Les Valeurs Par Défaut

Il n'est pas toujours nécessaire d'attribuer une valeur lorsqu'un champ est déclaré. Les Champs déclarés mais non initialisés seront définis sur a par défaut raisonnable par le compilateur. D'une manière générale, cette valeur par défaut sera zéro ou null, selon le type de données. En s'appuyant sur de tels les valeurs par défaut, cependant, est généralement considéré comme une mauvaise programmation style.

Le graphique suivant résume les valeurs par défaut pour les données ci-dessus type.

. . .

Les variables locales sont légèrement différentes; le compilateur n'attribue jamais valeur par défaut à une variable locale non initialisée. Si vous ne pouvez pas initialisez votre variable locale où elle est déclarée, assurez - vous de affecter une valeur avant de tenter de l'utiliser. L'accès à une une variable locale non initialisée entraînera une erreur de compilation.

Ce sont les principaux facteurs impliqués:

1. variable membre (OK par défaut)
2. variable statique (OK par défaut)
3. variable membre final (non initialisée, doit être définie sur le constructeur)
4. variable statique finale (non initialisée, doit être définie sur un bloc statique {})
5. variable locale (non initialisée)

Note 1: vous devez initialiser les variables membres finales sur chaque constructeur implémenté!

Note 2: vous devez initialiser les variables membres finales à l'intérieur le bloc du constructeur lui-même, n'appelant pas une autre méthode qui les initialise. Par exemple, ceci N'est pas valide:

private final int memberVar;

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

private void init() {
    memberVar = 10;
}

Note 3: les tableaux sont des objets en Java, même s'ils stockent des primitives.

Note 4: lorsque vous initialisez un tableau, tous ses éléments sont définis par défaut, indépendamment d'être un membre ou un tableau local.

Je joins un exemple de code, présentant les cas susmentionnés:

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
    }
}

Il y a quelques choses à garder à l'esprit lors de la déclaration de valeurs de type primitives.

Ils sont:

1. les valeurs déclarées dans une méthode ne recevront pas de valeur par défaut.
2. les valeurs déclarées comme variable instanciée ou une variable statique auront des valeurs par défaut assignées qui sont 0.

, Donc dans votre 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);

    }
}

Oui, la variable d'instance sera initialisée à la valeur par défaut, pour la variable locale, vous devez initialiser avant utilisation

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
    }
}

Les variables locales n'obtiennent pas de valeurs par défaut. Leurs valeurs initiales ne sont pas définies sans affecter des valeurs par certains moyens. Avant de pouvoir utiliser des variables locales, elles doivent être initialisées.

Il y a une grande différence lorsque vous déclarez une variable au niveau de la classe (en tant que membre ie. en tant que champ) et au niveau de la méthode.

Si vous déclarez un champ au niveau de la classe, ils obtiennent des valeurs par défaut en fonction de leur type. Si vous déclarez une variable au niveau de la méthode ou en tant que bloc (signifie anycode à l'intérieur {}) n'obtenez aucune valeur et restez indéfini jusqu'à ce qu'ils obtiennent des valeurs de départ, c'est-à-dire des valeurs qui leur sont assignées.

Toutes les variables membres doivent être chargées dans le tas afin qu'elles soient initialisées avec des valeurs par défaut lorsqu'une instance de classe est créée. Dans le cas de variables locales, elles ne sont pas chargées dans le tas, elles sont stockées dans la pile jusqu'à ce qu'elles soient utilisées avant java 7, nous devons donc les initialiser explicitement.

En java, l'initialisation par défaut s'applique uniquement à la variable d'instance du membre de la classe il n'est pas applicable pour les variables locales.