web-dev-qa-db-fra.com

Java: initialisation, déclaration et affectation des termes

Je trouve les defs circulaires, les sujets sont définis par leurs verbes mais les verbes ne sont pas définis! Alors, comment les définissez-vous?

Les définitions circulaires

initialisation: pour initialiser une variable. Cela peut être fait au moment de la déclaration

affectation: pour attribuer une valeur à une variable. Cela peut être fait n'importe où, seulement une fois avec l'identifiant final.

déclaration: pour déclarer une valeur à une variable.

[mise à jour, en essayant de comprendre le sujet avec lambda calc] 

D(x type) = (λx.x is declared with type) 
A(y D(x type)) = (λy.y is assigned to D(x type))

%Then after some beta reductions we get initialization.
D(x type) me human                  // "me" declared with type "human"
A(y (D(x type) me human)) asking    // "asking" assigned to the last declaration

%if the last two statemets are valid, an initialization exists. Right?
javainitializationdeclarationvariable-assignment
35
hhh

affectation : jeter l'ancienne valeur d'une variable et la remplacer par une nouvelle

initialisation : c'est un type particulier de tâche: la première. Avant l'initialisation, les objets ont la valeur null et les types primitifs, les valeurs par défaut telles que 0 ou false. Peut être fait en conjonction avec la déclaration.

déclaration : une déclaration indique le type d'une variable, ainsi que son nom. Une variable ne peut être déclarée qu'une fois. Il est utilisé par le compilateur pour aider les programmeurs à éviter les erreurs telles que l’attribution de valeurs de chaîne à des variables entières. Avant de lire ou d'assigner une variable, cette variable doit avoir été déclarée.

62
Silvio Donnini
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
60
John

Déclaration ne consiste pas à déclarer "valeur" à une variable; c'est déclarer le type de la variable.

L'affectation est simplement le stockage d'une valeur dans une variable.

L'initialisation est l'affectation d'une valeur à une variable au moment de la déclaration .

Ces définitions s'appliquent également aux champs.

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

Cependant, il convient de mentionner que "initialisation" a également une définition plus souple de "première affectation à une variable", quel que soit le lieu où cela 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

Ceci, cependant, 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 simple affectation. À cause de cela, si i était un tableau, vous ne pouvez pas utiliser la syntaxe abrégée d'initialiseur de tableau spéciale avec cette construction.

Donc, fondamentalement, "initialisation" a deux définitions possibles, selon le contexte:

  • Dans sa forme la plus étroite, c’est quand une assignation est combinée avec une déclaration .
    • Il permet, entre autres choses, une syntaxe spéciale d'initialisation de tableau
  • Plus généralement, c'est quand une affectation est faite pour la première fois à une variable .
    • Il permet, entre autres choses, d’assigner une variable final à plusieurs endroits .
      • Le compilateur fera de son mieux pour s’assurer que l’une de ces affectations peut se produire exactement, "initialisant" ainsi la variable final

Il y a aussi l'initialisation d'instance et de classe de contexte JVM, d'initialisation d'objet de contexte OOP, etc.

9
polygenelubricants

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

affectation : chaque fois que vous modifiez la valeur d'une variable en lui attribuant une nouvelle valeur

initialisation : affectation effectuée en même temps que la déclaration ou, en tout cas, première affectation effectuée avec une variable. Il s'agit généralement d'un appel de constructeur pour un objet ou d'une affectation simple pour une variable.

3
Jack

Voici une courte explication avec quelques exemples.

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

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

Initialisation: L'initialisation se produit lorsque nous mettons une valeur dans une variable, ceci se produit lorsque nous déclarons une variable.

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

Assignation: Une affectation consiste à déclarer ou à initialiser une variable et à modifier la valeur. Vous pouvez modifier la valeur de la variable autant de fois que vous le souhaitez ou dont vous avez besoin.

Exemple: 

int x = 7; x = 12; ....... Nous venons de changer la valeur.

String myName = "Emi"; myName = "John" ....... Nous venons de changer la valeur.

Boolean myCondition = false; myCondition = true; ....... Nous venons de changer la valeur.

Note: En mémoire sera sauvegardé la dernière valeur que nous avons mise.

3
Emm

Étape 1: Déclaration : int a;

Étape 2: Initialisation : a = 5;

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

0
user2934504

Je viens d’un contexte C/C++, mais les idées doivent être les mêmes.

Déclaration - Lorsqu'une variable est déclarée, il indique au compilateur de mettre de côté une partie de la mémoire et de lui associer un nom (et un type de variable). En C/C++, cela 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 doit 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 se trouve dans la ligne 

x = 3 + 5;

Il sait mettre la valeur entière 8 (pas la valeur à virgule flottante 8) dans l'emplacement mémoire également appelé «x».

Affectation - C'est à ce moment-là que vous insérez une valeur dans la variable précédemment déclarée. L'affectation est associée au «signe égal». Dans l'exemple précédent, la variable 8 était affectée à la variable 'x'.

Initialisation - Ceci est quand une variable est préréglée avec une valeur. Il n'y a aucune garantie qu'une variable sera définie sur une valeur par défaut lors de la déclaration de la variable (sauf si vous le spécifiez explicitement). On peut affirmer que l'initialisation est la première affectation d'une variable, mais ce n'est pas tout à fait vrai, comme je l'expliquerai bientôt. Une initialisation typique est un mélange de déclaration de variable avec une affectation comme suit:

int x = 6;

La distinction entre initialisation et assignation devient plus importante lorsqu'il s'agit de constantes telles que celle-ci ...

const int c = 15;

Lorsque vous utilisez des constantes, vous n'attribuez leur valeur qu'au moment de la déclaration/initialisation. Sinon, ils ne peuvent pas être touchés. Cela est dû au fait que les constantes se trouvent souvent dans la mémoire programme par rapport à la mémoire de données et que leur affectation réelle a lieu au moment de la compilation ou de l'exécution.

0
bill