Discussion :

[GhaziChaarii]

Bonjour

Pourquoi quand je change la valeur de b à 127 ou moins -127 le résultat devient true

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class A{
    Short b =200;
 
 
    public static void main(String[] args) {
        A a1 = new A(); 
        A a2 = new A(); 
 
 
        System.out.println( a2.b == a1.b);
 
    }
}

[joel.drigo]

Salut,

Tout d'abord, il faut différencier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Short b = 200;

de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

short b = 200;

Dans le premier cas, b "est" un objet de classe Short. Dans le second, b "est" une valeur de type primitif short.

Le signe == permet de tester l'identité :

1. pour les valeurs de type primitif, ça équivaut à l'égalité : 200 est identique à 200 car 200 est égal à 200 (et inversement).
2. pour les objets, l'identité teste l'égalité sur les références des objets (une sorte d'adresse mémoire pour simplifier, ou un identifiant unique pour la JVM si tu préfères).
   l'égalité, elle, se teste par la méthode equals : b.equals(c). Pour les types du genre Integer, Short, Double, Booolean etc... disons tous ceux qui ont un équivalent primitif, on peut faire aussi :
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   Short s=200;
   System.out.println( s.shortValue()==200 );

Ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
String s1 = new String("Bonjour");
String s2 = new String("Bonjour");
System.out.println(s1==s2); // 2 objets différents, donc false
System.out.println(s1.equals(s2)); // même chaîne de caractères donc true

affiche false puis true. Et c'est pareil pour les Short.

Quand tu écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Short b = 200;

Tu déclares donc une variable de nom b, de type objet Short, et tu lui affectes la valeur constante 200. Normalement, tu devrais écrire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Short b = new Short((short)200);

, comme pour instancier n'importe quel objet.
mais on peut écrire l'expression avec =200 (ce qui est tout de même plus simple) grâce à un élément de syntaxe de Java qui effectue ce qu'on appelle du "autoboxing" : la transformation automatique d'un type primitif en type objet correspondant. La valeur 200 est donc encapsulée (mise en boite = boxing) dans un objet.
Mais b "est" bien un objet de type Short et de valeur 200.

Alors pourquoi deux objets de type Short initialisés par la constante 127 sont identiques, alors que s'ils sont initialisés par 200, il ne sont plus identiques.
Parce qu'il y a une sorte de "cache", qui fait que les objets de valeurs entre -128 et 127 (inclus) sont créés une et une seule fois et réutilisés lorsqu'on utilise cette affectation.
Ainsi, lorsque tu écris :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Short a = 127;
Short b = 127;

C'est comme si tu écrivais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Short a = new Short((short)127);
Short b = a;

a et b contiennent la référence du même objet. (en fait pas tout à fait, parce Short c=127 ne sera pas identique à a, puisqu'on fait un new, mais c'est juste localement entre les deux variables et j'écris ça pour simplifier l'exemple).
Alors que quand tu écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Short a = 200;
Short b = 200;

C'est comme si tu écrivais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Short a = new Short((short)200);
Short b = new Short((short)200);

a et b ne sont plus le même objet.

Alors comment programmer et gérer cette histoire.

1. C'est mieux de savoir ce genre de choses, car ça permet de mieux comprendre ce qu'il se passe, et en particulier lorsque ça se passe mal (bug), ça permet de mieux comprendre où est le problème
2. mais lorsque tu programmes, tu ne dois pas en tenir compte (sauf exception, dans des cas précis, et quand tu maîtrises bien tous les impacts)
3. et donc en résumé : toujours tester l'égalité de 2 objets par la méthode equals(), jamais par ==.
4. et pour conclure, c'est toujours mieux utiliser le type primitif pour les nombres, les booléens, les caractères... : ça consomme moins de mémoire, c'est plus rapide à utiliser dans les traitements, et leur comportement est plus simple à comprendre :
   

   Code :

   Sélectionner tout - Visualiser dans une fenêtre à part

   1
   2
   short b=200;
   System.out.println( b==200);

   affiche bien true;

PS attention à ne pas utiliser :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Short s = 200;
System.out.println( s.equals(200) );

qui affichera false. Parce qu'ici pour le 200 passé en paramètre est autoboxé par défaut en Integer. Donc equals() va comparer 2 objets de types différents : Short et Integer, donc equals() sera forcément false.
Et si tu écris s==200, en revanche, s sera auto-unboxée (auto-unboxing) pour pouvoir être comparé à la constante 200 (et ça donnera true). Encore une raison de plus pour n'utiliser de préférence que des types primitifs.

[GhaziChaarii]

meeeeeeeeeeeeeeeeeeeeerci bcp