web-dev-qa-db-fra.com

Le constructeur par défaut n'initialise pas les membres d'instance de la classe?

J'ai rencontré une question qui demande "Parmi les propositions suivantes, lesquelles sont vraies concernant le constructeur" par défaut "?"

et une option "Il initialise les membres d'instance de la classe." était un choix incorrect.

Maintenant, je croyais comprendre que si nous avions un code tel que

    Class Test {
        String name;
    }

alors le compilateur crée le constructeur par défaut qui ressemble à

    Class Test {
        String name;
        Test(){
            super();
            name = null;
        }
    }

Le constructeur par défaut n’initialise-t-il pas le nom du membre d’instance = null?

javaconstructordefault-constructor
15
SERich

Le constructeur de classe n'est pas celui qui effectue l'initialisation, c'est la JVM qui le fait. Après la création de la mémoire pour l'objet, les membres de l'objet sont initialisés par défaut à une valeur prévisible, qui devient leur valeur par défaut.

Selon la spécification

  • Chaque variable de classe, variable d'instance ou composant de tableau est initialisé avec une valeur par défaut lors de sa création ( §15.9 , §15.10.2 ):
    • Pour le type octet, la valeur par défaut est zéro, c'est-à-dire la valeur de (byte)0.
    • Pour le type short, la valeur par défaut est zéro, c'est-à-dire la valeur de (short)0.
    • Pour le type int, la valeur par défaut est zéro, c'est-à-dire 0.
    • Pour le type long, la valeur par défaut est zéro, c'est-à-dire 0L.
    • Pour le type float, la valeur par défaut est positive zéro, c'est-à-dire 0.0f.
    • Pour le type double, la valeur par défaut est positive zéro, c'est-à-dire 0.0d.
    • Pour le type char, la valeur par défaut est le caractère null, c'est-à-dire '\u0000'.
    • Pour le type boolean, la valeur par défaut est false.
    • Pour tous les types de référence ( §4.3 ), la valeur par défaut est null.

Votre hypothèse est proche mais le fait est que, avant même que les paramètres du constructeur ne soient évalués (avant même de pouvoir affecter une valeur à chacun des champs), ces champs conservent déjà leurs valeurs par défaut, comme le fait la machine virtuelle Java.

Lisez la sous-section §15.9.4 pour comprendre comment se déroule le processus d’initialisation

10
smac89

En Java, les champs sont initialisés avant le constructeur. Cela peut être facilement prouvé par le code suivant:

public class MyClass {

    int myField = initMyField();

    MyClass(){
        System.out.println("ctor");
    }

    static int initMyField() {
        System.out.println("init field");
        return 1;
    }
}

sortie

init field
ctor

Vous pouvez également vérifier le code décompilé.

4
Danny Chen

Le constructeur par défaut n'initialise-t-il pas le membre d'instance name = null?

Non, les constructeurs sont appelés après toutes les variables d'instance sont initialisées avec les valeurs par défaut: 0 ou la valeur équivalente pour types numériques primitifs , false pour le type boolean, null pour types de référence .

3
Andrew Tobilko

Non, ce n'est pas le constructeur par défaut qui initialise les variables d'instance pour vous. Chaque type a une valeur par défaut. Au moment où vous créez l'objet, la valeur par défaut est utilisée.

Ainsi, si vous n'initialisez pas explicitement les variables d'instance, elles continueront d'utiliser les valeurs par défaut définies de manière implicite.

c'est-à-dire 0 pour int, null pour le type de référence, etc.

Cependant, il convient de noter que nous ne devrions pas prendre pour acquis qu’une valeur par défaut est donnée et choisir de ne pas initialiser les variables.

Vous pouvez essayer de définir un constructeur vide qui remplace le constructeur par défaut avec une implémentation vide. Vous réaliserez que toutes les variables d'instance seront toujours initialisées.

1
user3437460

Cela fait. Bien que la question repose davantage sur l'utilisation.

public class Main {
    String x;

    Main() {
        x = "Init";
    }

    @Override
    public String toString() {
        return x;

    }

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

}

Sortie:

Init
1
RCInd

Chaque fois que nous exécutons une classe Java, le premier flux de contrôle statique sera exécuté. Dans le flux de contrôle statique, si nous créons un objet, les étapes suivantes seront exécutées (dans l'ordre indiqué) dans le cadre du flux de contrôle Inatance:

  1. Identification des membres d'instance (variable d'instance et blocs d'instance) de haut en bas.
  2. Exécution des affectations de variables d'instance et des blocs d'instance.
  3. Exécution du constructeur.

Ainsi, dans le code ci-dessus, la variable d’instance "nom" est déjà affectée à la valeur null (valeur par défaut pour les types de référence) avant même l’exécution du constuctor.

0
Rajdeep Sarkar

Le constructeur par défaut fournit les valeurs par défaut aux objets et est normalement créé par le compilateur quand aucun constructeur n'est explicitement défini. par exemple.

class DefaultTest{  
int id;  
String name;  

void display(){System.out.println(id+" "+name);}  

public static void main(String args[]){  
DefaultTest s1=new DefaultTest();  
DefaultTest s2=new DefaultTest();  
s1.display();  
s2.display();  
}  
}

NB: En l'absence de constructeur défini, le compilateur générera un constructeur par défaut qui affectera 0 valeur nulle aux deux objets.

0
mc.Ambugo