Java: définir les Termes initialisation, déclaration et assignation

String declaration;
String initialization = "initialization";
declaration = "initialization"; //late initialization - will initialize the variable.
    // Without this, for example, in java, you will get a compile-time error if you try 
    // to use this variable.

declaration = "assignment"; // Normal assignment. 
    // Can be done any number of times for a non-final variable

déclaration n'est pas de déclarer "valeur" à une variable; il est de déclarer le type de la variable.

Cession est tout simplement le stockage d'une valeur à une variable.

Initialisation est l'assignation d'une valeur à une variable au moment de la déclaration .

ces définitions s'appliquent également aux zones.

int i;  // simple declaration
i = 42  // simple assignment

int[] arr = { 1, 2, 3 };
// declaration with initialization, allows special shorthand syntax for arrays

arr = { 4, 5, 6 }; // doesn't compile, special initializer syntax invalid here
arr = new int[] { 4, 5, 6 }; // simple assignment, compiles fine

toutefois, il convient de mentionner que la "initialisation" a également une définition plus souple de "la première affectation à une variable", indépendamment de l'endroit où elle se produit.

int i; // local variable declaration
if (something) i = 42;
System.out.println(i);
  // compile time error: The local variable i may not have been initialized

toutefois, Cette compile:

int i; // the following also compiles if i were declared final
if (something) i = 42;
else i = 666;
System.out.println(i);

ici i peut être" initialisé " à partir de deux emplacements possibles, par des assignations simples. Pour cette raison ,si i était un tableau, vous ne pouvez pas utiliser la syntaxe shorthand spéciale d'initialiseur de tableau avec ceci construire.

donc fondamentalement "initialisation" a deux définitions possibles, en fonction du contexte:

• dans sa forme la plus étroite, c'est quand une cession est combinée avec une déclaration.
  • il permet, entre autres choses, un tableau spécial syntaxe shorthand initializer
• plus généralement, c'est lorsqu'une affectation est faite pour la première fois à une variable.
  • Il permet, entre autres choses, des assignations à une variable final à plusieurs endroits.
    • le compilateur ferait de son mieux pour s'assurer que exactement l'une de ces assignations peut se produire, "initialisant" ainsi la" variable final 1519330920"

il y a aussi JVM-context class et instance initialization, OOP-context object initialization, etc.

déclaration : chaque fois que vous définissez une nouvelle variable avec son type

assignation : chaque fois que vous changez la valeur d'une variable en lui donnant une nouvelle valeur

initialization : une tâche qui est faite avec la déclaration, ou dans tous les cas la première tâche qui est faite avec une variable, habituellement c'est un appel de constructeur pour un objet ou une tâche simple pour une variable

Voici une brève explication avec quelques exemples.

déclaration: La déclaration est lorsque vous déclarez une variable avec un nom, et une variable peut être déclarée qu'une seule fois.

exemple: int x; , String myName; , Boolean myCondition;

initialisation: L'initialisation est quand nous mettons une valeur dans une variable, cela se produit pendant que nous déclarons une variable.

exemple: int x = 7; , String myName = "Emi"; , Boolean myCondition = false;

affectation: Assignment est quand nous avons déjà déclaré ou initialisé une variable, et nous changeons la valeur. Vous pouvez changer la valeur de la variable autant de fois que vous voulez ou que vous avez besoin.

exemple:

int x = 7; x = 12; .......On vient de changer la valeur.

String myName = "Emi"; myName = "John" .......On vient de changer la valeur.

Boolean myCondition = false; myCondition = true; .......On vient de changer la valeur.

Remarque: Dans la mémoire seront sauvés à la dernière valeur que nous avons mis.

je viens d'un arrière-plan C/C++, mais les idées devraient être les mêmes.

déclaration - Lorsqu'une variable est déclarée, c'est dire au compilateur de mettre de côté un morceau de mémoire et d'y associer un nom (et un type de variable). En C / C++ il pourrait ressembler à ceci:

int x;

le compilateur voit cela et met de côté un emplacement d'adresse pour x et sait quelles méthodes il devrait utiliser pour effectuer des opérations sur x (différents types de variables utiliseront différentes opérations d'accès). De cette façon, lorsque le compilateur entre dans la ligne

x = 3 + 5;

il sait mettre la valeur entière 8 (pas la valeur de virgule flottante 8) dans l'emplacement de mémoire également connu sous le nom de 'x'.

Assignment - c'est quand vous mettez une valeur dans la variable précédemment déclarée. La cession est associée au signe "égal". Dans l'exemple précédent, la variable "x" a reçu la valeur 8.

initialisation - c'est quand une variable est prédéfinie avec une valeur. Il n'y a aucune garantie qu'une variable sera définie à une valeur par défaut pendant la déclaration de la variable (à moins que vous ne le fassiez explicitement). On peut faire valoir que l'initialisation est la première affectation d'une variable, mais ce n'est pas tout à fait vrai, comme je l'expliquerai sous peu. Une initialisation typique est un mélange de la déclaration variable avec un affectation comme suit:

int x = 6;

la distinction entre l'initialisation et l'assignation devient plus importante lorsqu'on traite de constantes, comme celle-ci...

const int c = 15;

lorsqu'il s'agit de constantes, vous ne pouvez attribuer leur valeur qu'au moment de la déclaration/initialisation. Sinon, ils ne peuvent pas être touché. Ceci est dû au fait que les constantes sont souvent localisées dans la mémoire du programme par rapport à la mémoire des données, et que leur assignation réelle se produit à le temps de compilation vs moment de l'exécution.

Étape 1: déclaration : int a;

Étape 2: initialisation : a = 5;

Étape 3: affectation : A = b; (ex: int b = 10 ; maintenant a devient 10)