Classes wrapper en Java

Salut! Vous connaissez déjà bien les types primitifs et avez pas mal travaillé avec eux. En programmation (et en Java en particulier), les primitives présentent de nombreux avantages : elles utilisent peu de mémoire (et donc rendent le programme plus efficace) et ont une plage de valeurs clairement délimitée. Cependant, en apprenant Java, nous avons déjà souvent répété le mantra "tout en Java est un objet". Mais les primitifs contredisent directement ces mots. Ce ne sont pas des objets. Alors, notre principe « tout est objet » est-il faux ? En fait, ce n'est pas le cas. En Java, chaque type primitif a un frère jumeau, une classe wrapper.

Qu'est-ce qu'une classe wrapper ?

Un wrapper est une classe spéciale qui stocke une primitive en interne. Mais comme il s'agit d'une classe, vous pouvez en créer des instances. Ils stockent les valeurs primitives en interne, mais sont toujours de vrais objets. Les noms de classe wrapper sont très similaires (ou exactement identiques) aux noms de leurs primitives correspondantes. Ils sont donc faciles à retenir. Les objets wrapper sont créés de la même manière que n'importe quel autre objet :

public static void main(String[] args) {

   Integer i = new Integer(682);
  
   Double d = new Double(2.33);
  
   Boolean b = new Boolean(false);
}

Les classes wrapper nous permettent d'atténuer les défauts des types primitifs. La plus évidente est que les primitives n'ont pas de méthodes. Par exemple, ils n'ont pas de méthode toString() , vous ne pouvez donc pas, par exemple, convertir un int en String . Mais la classe wrapper Integer rend cela facile.

public static void main(String[] args) {

   Integer i = new Integer(432);
  
   String s = i.toString();
}

Cependant, la conversion dans l'autre sens peut être plus délicate. Disons que nous avons un String , dont nous savons avec certitude qu'il contient un nombre. Quoi qu'il en soit, il n'existe aucun moyen natif d'utiliser un int primitif pour extraire le nombre de la chaîne et le convertir en nombre. Mais, nous pouvons avec les classes wrapper.

public static void main(String[] args) {

   String s = "1166628";

   Integer i = Integer.parseInt(s);

   System.out.println(i);
}

Sortir:

1166628

Nous avons extrait avec succès un nombre de la chaîne et l'avons affecté à la variable de référence Integer i . Au fait, concernant les références. Vous savez déjà que les arguments sont passés aux méthodes de différentes manières : les primitives par valeur et les objets par référence. Vous pouvez utiliser ces connaissances lors de la création de vos propres méthodes : par exemple, si votre méthode utilise des nombres fractionnaires mais que vous avez besoin de logique pour passer par référence, vous pouvez passer des arguments Double / Float à la méthode au lieu de double / float . En plus des méthodes des classes wrapper, leurs champs statiques peuvent également être très pratiques. Par exemple, imaginez que vous ayez la tâche suivante : afficher le maximum devaleur int , suivie de la valeur minimale possible. Ce problème semble assez basique. Mais sans Google, il est peu probable que vous puissiez le faire. Mais les wrappers vous permettent de gérer facilement ces "tâches banales":

public class Main {
   public static void main(String[] args) {

       System.out.println(Integer.MAX_VALUE);
       System.out.println(Integer.MIN_VALUE);
   }
}

Ces champs vous évitent d'être distrait par l'accomplissement de tâches plus sérieuses. Sans parler du fait que taper 2147483647 (qui se trouve être la valeur de MAX_VALUE) n'est pas une mince affaire ! :) De plus, dans une leçon précédente, nous avons souligné que les objets wrapper sont immuables.

public static void main(String[] args) {

   Integer a = new Integer(0);
   Integer b = new Integer(0);

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

Sortir:

0

L'état de l'objet initialement pointé par a n'a pas changé (parce que la valeur de b aurait également changé). Comme avec String s, au lieu de changer l'état de l'objet wrapper, un objet entièrement nouveau est créé en mémoire. Alors, pourquoi les créateurs de Java ont-ils finalement décidé de laisser les types primitifs dans le langage ? Puisque tout devrait être un objet, et que nous avons des classes wrapper qui peuvent exprimer tout ce que les primitives expriment, pourquoi ne pas seulement garder les wrappers dans le langage et supprimer les primitives ? La réponse est simple : les performances. Les types primitifs sont appelés primitifs car ils manquent de nombreuses fonctionnalités "lourdes" des objets. Oui, les objets ont de nombreuses méthodes pratiques, mais vous n'en avez pas toujours besoin. Parfois, tout ce dont vous avez besoin est le nombre 33, ou 2,62, ou vrai / faux . Dans les situations où les avantages des objets n'ont pas d'importance et ne sont pas nécessaires au fonctionnement du programme, les primitives sont bien mieux adaptées à la tâche.