CodeGym/Cours Java/Module 1/types d'emballage

types d'emballage

Disponible

1. Liste des types d'emballages

Vous savez que Java a 8 types primitifs, qui sont des types qui ne sont pas des classes. D'une part, c'est bien - ils sont simples et prennent peu de place. D'un autre côté, parfois, les cours sont exactement ce dont nous avons besoin. Vous découvrirez exactement pourquoi dans la prochaine leçon.

Alors qu'est ce qui peut être fait?

À partir de la cinquième version de Java, chaque type primitif a gagné une classe jumelle. Chacune de ces classes stocke un seul champ avec une valeur d'un type spécifique. Ces classes sont appelées types wrapper , car elles encapsulent des valeurs primitives dans des classes.

Voici une liste de ces types. En connaissez-vous?

Type primitif Classe wrapper
byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
char
Character
boolean
Boolean

Les noms des types primitifs commencent par une lettre minuscule, mais les noms des classes wrapper commencent par une lettre majuscule. Certains des noms de classe sont également un peu plus longs : Integerinstead of intи Characterinstead of char.

Tous les objets des classes wrapper sont inchangeables ( immutable ).

Le code simplifié pour la Integerclasse ressemble à ceci :

Code Note
public class Integer
{
   private int value;

   Integer(int x)
   {
      this.value = x;
   }

   public int intValue()
   {
      return this.value;
   }

   public static Integer valueOf(int x)
   {
      return new Integer(x);
   }
}




Constructeur de variable




La méthode renvoie une valeur




La méthode statique crée un nouvel Integerobjet pour une intvariable

2. Conversion d'un inten unInteger

Les types wrapper sont considérés comme des homologues de leurs frères et sœurs primitifs : vous pouvez facilement créer un objet wrapper qui correspond à un type primitif.

Utilisons le type int comme exemple pour analyser comment les types primitifs interagissent avec leurs types wrapper correspondants. Le code pour convertir de an inten an Integeret vice versa ressemblerait à ceci :

Pour convertir an inten an Integer, vous devez écrire ce code :

Integer name = new Integer(value);

nameest le nom d'une Integervariable, et valueest la intvaleur encapsulée.

Exemples:

Code Note
Integer age = new Integer(18);
Integer hundred = new Integer(100);
Integer zero = new Integer(0);

Et pour convertir le an Integeren an int, vous devez écrire ce code :

int name = variable.intValue();

nameest le nom d'une intvariable et variableest une référence à un Integerobjet.

Exemples:

Code Note
Integer age = new Integer(18);
int x = age.intValue();

x == 18
Integer hundred = new Integer(100);
int y = hundred.intValue();

y == 100
Integer zero = new Integer(0);
int z = zero.intValue();


z == 0
int i = 110;
Integer zero = new Integer(i);
int z = zero.intValue();

z == 110

3. Boîte automatique et déballage

Mais même des opérations simples avec le Integertype ne sont pas faciles à écrire.

Comme nous l'avons dit précédemment, le Integertype est immuable (unchangeable ) . Pour créer un Integerobjet avec une nouvelle intvaleur, vous devez créer explicitement un nouvel Integerobjet. Cela dit, il est facile d'obtenir la valeur d'un intstocké à l'intérieur d'un Integerobjet - il suffit d'appeler la intValue()méthode.

Exemple:

Code Description
Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = new Integer(b + 5)
Envelopper 5un Integerobjet
Obtenir la valeur de l' Integerobjet
Créer un nouvel Integerobjet (égal à 10)

C'est un code plutôt lourd, vous ne pensez pas ?

Les créateurs de Java l'ont pensé, alors ils ont appris au compilateur comment faire ces opérations automatiquement. La conversion automatique de an inten an Integers'appelle autoboxing (mettre automatiquement la valeur dans une case) et l'opération inverse (convertir an Integeren an int) s'appelle unboxing .

Votre code Ce que voit le compilateur
Integer a = 10;
Integer a = Integer.valueOf(10);
int b = a;
int b = a.intValue();
Integer c = a + b;
Integer c = Integer.valueOf(a.intValue() + b);

Grâce à l'autoboxing et à l'unboxing, vous pouvez affecter en toute sécurité un intà une Integervariable et vice versa. Vous pouvez écrire des expressions de n'importe quelle complexité sans faire de distinction entre les types intet Integer.

Exemples:

Code Ce que le compilateur va générer
Integer a = 5;
int b = a;
Integer c = a + b;
int d = a + b + c;
Integer a = Integer.valueOf(5);
int b = a.intValue();
Integer c = Integer.valueOf(a.intValue() + b);
int d = a.intValue() + b + c.intValue();
Integer a = 5;
int b = 5;

if (a == b)
{
   ...
}
Integer a = Integer.valueOf (5);
int b = 5;

if (a.intValue() == b)
{
   ...
}


4. Comparer les variables wrapper

L'autoboxing et l'unboxing sont des processus simples et transparents. Nous utilisons new Integer()des instructions selon les besoins et nous appelons la intValue()méthode selon les besoins.

Tout fonctionne bien et facilement pour vous, le programmeur. N'oubliez pas que si vous comparez an Integeret an Integer, la comparaison est basée sur une référence et non sur des valeurs.

Code Sortie console
Integer a = 1000;
Integer b = 1000;

System.out.println(a == b);



false
Integer a = 1000;
Integer b = 1000;

System.out.println(a.equals(b));



true

Les variables aet bne stockent pas intde valeurs. Ils stockent des références à des objets. Cela signifie qu'il est important de se rappeler comment les comparer correctement :

Faux Droite
Integer a = 1000;
Integer b = 1000;
if (a == b)
{
   ...
}
Integer a = 1000;
Integer b = 1000;
if (a.equals(b))
{
   ...
}

Commentaires
  • Populaires
  • Nouveau
  • Anciennes
Tu dois être connecté(e) pour laisser un commentaire
Cette page ne comporte pas encore de commentaires