REPUBLIQUE TOGOLAISE ANNEE UNIVERSITAIRE
TRAVAIL-LIBERTE-PATRIE 2023-2024
POO APLICATIONS IRT1
THEME :
Les wrappers
Groupe N03
Membres du groupe :
BISHARIZA DJIKOUNOU (Responsable)
BOUKARI DOGBEVI
DAGBEGNON DOTTO
DAKOU DZAHINI
DANTODJI DZOKPE
DAOUDA EDJEMOU
DAYO EDOH
DEGBOE EFIA
DIABO GADEWOSSI
DJAGO OUANTI
Chargé du cours : [Link]
Plan Détaillé
Introduction
I-Définition
1
II-Exemple d'utilisation
III-Mode d'utilisation
1-Types de Wrappers
2-Méthodes
IV- Avantages
[Link] de types :
[Link] dans les collections :
3.Méthodes utiles :
[Link] par référence :
V- Inconvénients ou limites
Conclusion
Introduction
En programmation orientée objet, on fait appel à des patrons de structure, qui
fonctionnent de manière identique quel que soit le langage utilisé. Les patrons
de conception adaptateur et décorateur entrent dans la catégorie de ces
patrons de structure et sont considérés comme des wrappers. Ainsi dans cet
exposé, nous essayerons de voir toutes les facettes de cette structure.
I- Définition
2
En anglais, le terme « wrapper » désigne entre autres un papier d’emballage ou
une jaquette de livre. Dans le domaine informatique, le terme désigne un
programme ou code qui « enveloppe », ou englobe, d’autres composants
logiciels. Plusieurs raisons motivent le recours aux wrappers.
II-Exemple d’utilisation (Code)
III-Mode d'utilisation
1- Types de Wrappers
Les wrappers en Java sont des classes fournies par le langage Java pour
encapsuler les types primitifs et les convertir en objets. Cela permet d'utiliser
des types primitifs là où des objets sont nécessaires, notamment dans le
contexte de la programmation orientée objet où seuls les objets peuvent être
utilisés.
Il existe huit wrappers en Java correspondant aux types primitifs :
3
. Integer : Wrapper pour int.
. Double : Wrapper pour double.
. Float : Wrapper pour float.
. Long : Wrapper pour long.
. Short : Wrapper pour short.
. Byte : Wrapper pour byte.
. Character : Wrapper pour char.
. Boolean : Wrapper pour boolean.
2-Méthodes
Voici quelques exemples de méthodes couramment utilisées avec les wrappers
en Java :
valueOf() : Convertit une chaîne en un objet de type wrapper.
parseXxx() : Convertit une chaîne en un type primitif.
intValue(), longValue(), floatValue(), doubleValue() : Renvoie la valeur
primitive du wrapper.
toString() : Convertit le wrapper en une chaîne.
equals() : Compare deux objets wrapper pour l'égalité.
La méthodologie des wrappers en Java est souvent utilisée dans des situations
où des objets sont requis, comme dans les collections génériques
(ArrayList<Integer>, par exemple), lors de l'utilisation de structures de données
dans les API ou lorsque la manipulation de types primitifs est plus pratique sous
forme d'objets.
IV- Avantages
Les wrappers en Java offrent plusieurs avantages. En voici quelques-uns :
1. Conversion de types :
Les wrappers permettent de convertir facilement des valeurs entre types
primitifs et objets. Par exemple, vous pouvez convertir un int en String en
utilisant le wrapper Integer.
2. Utilisation dans les collections :
4
Comme je l'ai mentionné précédemment, les collections en Java ne peuvent
stocker que des objets. Les wrappers permettent donc d'utiliser des types
primitifs dans des collections génériques, comme ArrayList ou HashSet.
3. Méthodes utiles :
Les wrappers fournissent des méthodes utiles pour effectuer des opérations
sur les types primitifs. Par exemple, le wrapper Integer offre des méthodes
pour effectuer des opérations mathématiques, comparer des valeurs, ou
convertir des chaînes de caractères en entiers.
4. Passage par référence :
Lorsque vous passez un wrapper en tant que paramètre à une méthode, vous
passez une référence à l'objet encapsulant le type primitif. Cela signifie que toute
modification apportée à l'objet à l'intérieur de la méthode sera visible à
l'extérieur de la méthode.
V- Inconvénients ou limites
L'utilisation des wrappers en Java présente quelques inconvénients :
Performance : Les types primitifs sont généralement plus performants que
leurs équivalents en wrapper car ces derniers nécessitent de la mémoire
supplémentaire pour stocker les objets.
Complexité : L'utilisation de wrappers peut rendre le code plus complexe en
raison de la nécessité de déballer et d'emballer les valeurs primitives dans les
objets.
Comparaisons : Les comparaisons entre wrappers nécessitent souvent
l'utilisation de méthodes spécifiques comme equals() au lieu des opérateurs de
comparaison classiques, ce qui peut rendre le code moins lisible.
Nullabilité : Les wrappers peuvent être null, ce qui peut entraîner des erreurs
NullPointerException si on ne fait pas attention à la gestion des nulls.
Surcharge de la mémoire : L'utilisation de wrappers peut surcharger la
mémoire, surtout dans les applications qui manipulent de grandes quantités de
données primitives, en raison de l'overhead supplémentaire des objets.
Conclusion
En résumé, les wrappers en Java facilitent la manipulation des types primitifs
comme des objets, améliorant ainsi la flexibilité et la compatibilité dans le
développement Java.