Les opérateurs d'affectation permettent l'assignation d'une valeur à une variable.

variable opérateur valeur;

L'opérateur d'affectation de base est le signe d'égalité (=), qui assigne la valeur de son opérande droit à son opérande gauche. C'est-à-dire, droit = gauche assigne la valeur de gauche à droite.

variable = valeur;

Il est également possible de combiner les opérations d'affectation et de calcul par l'intermédiaire d'un opérateur spécial.

variable op= valeur;
// est équivalent à
variable = variable op valeur;

x += 5; // correspond à x = x + 5;

y /= 2; // correspond à y = y / 2;

La promotion arithmétique assure la compatibilité entre le type de chacune des opérandes, par une conversion au type plus large de l'opérande la plus faible si les types sont compatibles, sinon le compilateur génère une erreur si le transtypage doit être explicite.

Pour une affectation simple et combinée de valeurs primitives numériques, le type de l'opérande de gauche doit être identique ou plus large que celui de l'opérande de droite, sinon une erreur de dépassement de capacité peut se produire lors du temps d'exécution.

type_opeD operandeD;
type_opeG operandeG op= operandeD;
// est équivalent à
type_opeG operandeG op= (type_opeG)operandeD;

class op {
  public static void main(String[] args){
  byte   w = 8;
  int  x = 422;
  float  y = 12.4f;
  double z = 448.3641d;

  System.out.println("1 : " + w + " += " + x + " = " + (w += x));
  System.out.println("2 : " + x + " += " + y + " = " + (x += y));
  System.out.println("3 : " + y + " += " + z + " = " + (y += z));
  System.out.println("4 : " + w + " += " + z + " = " + (w += z));
  System.out.println("5 : " + z + " += " + w + " = " + (z += w));
  System.out.println("6 : " + x + " += " + w + " = " + (x += w));
  }
}
// affiche
1 : 8 += 422 = -82 // erreur
2 : 422 += 12.4 = 434
3 : 12.4 += 448.3641 = 460.7641
4 : -82 += 448.3641 = 110 // erreur
5 : 448.3641 += 110 = 558.3641
6 : 434 += 110 = 544

Pour une affectation d'objets, les types références doivent être compatibles entre eux, sinon le compilateur générera une erreur.

• Les classes doivent donc être identiques ou le type de l'opérande de gauche doit être une superclasse.
• Si l'opérande de gauche possède un type représentant une interface, l'opérande de droite doit implémenter cette interface.
• Si l'opérande de gauche possède un type Object, l'opérande de droite peut être de n'importe quel type.

interface Inter { ... }
class SuperClasse implements inter { ... }
class Classe extends SuperClasse { ... }

class Affectation {
  public static void main(String[] args){
  Classe RefObjD = new Classe();
  Classe RefObjG = RefObjD;
  // ou
  SuperClasse RefObjG = RefObjD;
  // est équivalent à
  SuperClasse RefObjG = (SuperClasse)RefObjD;

  Object RefObjO = RefObjG;
  // est équivalent à
  Object RefObjO = (Object)RefObjG;

  Inter RefObjI = RefObjG;
  // est équivalent à
  Inter RefObjI = (Inter)RefObjG;
  }
}

Opérateur	Equivalent	Description
x = y		y est affecté à x
x += y	x = x + y	y est additionné à x
x -= y	x = x - y	y est soustrait de x
x *= y	x = x * y	x est multiplié par y
x /= y	x = x / y	x est divisé par y
x %= y	x = x % y	le reste de x/y est affecté à x
x <<= n	x = x << n	x décalé à gauche de n bits est affecté à x.
x >>= n	x = x >> n	x décalé à droite en propageant le bit de signe de n bits est affecté à x.
x >>>= n	x = x >>> n	x décalé à droite de n bits est affecté à x.
x &= n	x = x & y	x est comparé binairement selon un ET à Y et est affecté à x.
x |= y	x = x | y	x est comparé binairement selon un OU à Y et est affecté à x
x ^= y	x = x ^ y	x est comparé binairement selon un OU INCLUSIF à Y et est affecté à x