Programmation Orientée Objet – Java Les types paramétrés Types

Java
Types génériques et paramétrés
Les types paramétrés
Supposons que nous ayons la classe suivante :
public class Stack {
private Object[] stack = new Object[100];
private int size = 0;
Programmation Orientée Objet – Java
public void push(Object object) {
stack[size] = object; size++;
}
Bertrand Estellon
Département Informatique et Interactions
Aix-Marseille Université
public Object pop() {
size--; Object object = stack[size];
stack[size]=null; // Pour le Garbage Collector.
return object;
}
21 septembre 2016
}
Bertrand Estellon (DII – AMU)
Programmation Orientée Objet – Java
Java
21 septembre 2016
1 / 171
Programmation Orientée Objet – Java
Java
Types paramétrés
21 septembre 2016
117 / 171
Types génériques et paramétrés
Types paramétrés
Par conséquent, on souhaiterait pouvoir préciser le type des éléments :
Nous rencontrons le problème suivant :
Stack stack = new Stack();
String string = "truc";
stack.push(string);
string = (String)stack.pop(); // Transtypage obligatoire !
Nous avons également le problème suivant :
Stack stack = new Stack();
Integer integer = new Integer(2);
stack.push(integer);
String string = (String)stack.pop(); // Erreur à l'exécution
Bertrand Estellon (DII – AMU)
Bertrand Estellon (DII – AMU)
Types génériques et paramétrés
Programmation Orientée Objet – Java
21 septembre 2016
118 / 171
Stack<String> stack = new Stack<String>();
String string = "truc";
stack.push(string); // Le paramètre doit être un String.
string = stack.pop();
// La méthode retourne un String.
Java nous permet de définir une classe Stack qui prend en paramètre un
type. Ce type paramétré va pouvoir être utilisé dans les signatures des
méthodes et lors de la définition des champs de la classe.
Lors de la compilation, Java va utiliser le type paramétré pour effectuer :
▶
des vérifications de type ;
▶
des transtypages automatiques ;
▶
des opérations d’emballage ou de déballage de valeurs.
Bertrand Estellon (DII – AMU)
Programmation Orientée Objet – Java
21 septembre 2016
119 / 171
Java
Types génériques et paramétrés
Java
Classes paramétrées
Emballage et déballage
La nouvelle version de la classe Stack :
Les types simples ne sont pas des classes :
public class Stack<T> {
private Object[] stack = new Object[100];
private int size = 0;
Stack<int> stack = new Stack<int>(); // interdit !
Dans ce cas, on doit utiliser la classe d’emballage Integer :
public void push(T t) { stack[size] = t; size++; }
Stack<Integer> stack = new Stack<Integer>();
int intValue = 2;
Integer integer = new Integer(intValue);
// ,→ emballage du int dans un Integer.
stack.push(integer);
integer = stack.pop();
intValue = integer.intValue();
// ,→ déballage du int présent dans le Integer.
public T pop() {
size--;
T t = (T)stack[size];
stack[size] = null;
return t;
}
}
Bertrand Estellon (DII – AMU)
Types génériques et paramétrés
Programmation Orientée Objet – Java
Java
21 septembre 2016
120 / 171
Bertrand Estellon (DII – AMU)
Types génériques et paramétrés
Programmation Orientée Objet – Java
Java
Rappel : Les types primitifs
21 septembre 2016
121 / 171
Types génériques et paramétrés
Classes d’emballage
Les classes d’emballage :
byte
short
int
long
float
double
char
boolean
entier
entier
entier
entier
flotant
flotant
caractère
boolean
8 bits
16 bits
32 bits
64 bits
32 bits
64 bits
16 bits
1 bit
-128 à 127
-32768 à 32767
−231 à 231 − 1
−263 à 263 − 1
caractères Unicode
false ou true
0
0
0
0
0.0
0.0
\u0000
false
▶
▶
▶
▶
▶
▶
▶
▶
Bertrand Estellon (DII – AMU)
Programmation Orientée Objet – Java
21 septembre 2016
122 / 171
Byte → public Byte(byte b)
Short → public Short(short s)
Integer → public Integer(int i)
Long → public Long(long l)
Float → public Float(float f)
Double → public Double(double d)
Boolean → public Boolean(boolean b)
Character → public Character(char c)
Bertrand Estellon (DII – AMU)
Programmation Orientée Objet – Java
21 septembre 2016
123 / 171
Java
Types génériques et paramétrés
Java
Emballage et déballage automatique
Types génériques et paramétrés
Structures de données Java
Des interfaces :
▶
Depuis Java 5, il existe l’emballage et le déballage automatique :
Collection<V> : Groupe d’éléments
▶
▶
Stack<Integer> stack = new Stack<Integer>();
int intValue = 2;
stack.push(intValue);
// ,→ emballage automatique du int dans un Integer.
intValue = stack.pop();
// ,→ déballage automatique du int.
▶
▶
▶
List<V> : Liste d’éléments ordonnés et accessibles via leur indice
Set<V> : Ensemble d’éléments uniques
Queue<V> : Une file d’éléments (FIFO)
Deque<V> : Une file à deux bouts (FIFO-LIFO)
Map<K,V> : Ensemble de couples clé-valeur.
Il est préférable d’utiliser les interfaces pour typer les variables :
Attention : il est important de noter que des allocations sont effectuées
lors des emballages sans que des new soient présents dans le code.
List<Integer> list = new ArrayList<Integer>();
/* code qui utilise list. */
car on peut changer la structure de données facilement :
List<Integer> list = new LinkedList<Integer>();
/* code qui utilise list et qui n'a pas à être modifié. */
Bertrand Estellon (DII – AMU)
Programmation Orientée Objet – Java
Java
21 septembre 2016
124 / 171
Programmation Orientée Objet – Java
Java
Structures de données Java
125 / 171
Implémentations de Set<V> :
▶
ArrayList<V> : Tableau dont la taille varie dynamiquement.
▶
LinkedList<V> : Liste chaînée.
▶
Stack<V> : Pile (mais une implémentation de Deque est préférable).
Implémentations de Map<K,V> :
▶
HashSet<V> : Avec une HashMap.
▶
LinkedHashSet<V> : Avec une LinkedHashMap.
▶
TreeSet<V> : Avec une TreeMap.
Implémentations de Deque<V> :
▶
HashMap : Table de hachage.
▶
LinkedHashMap : Table de hachage + listes chainées.
▶
TreeMap : Arbre rouge-noir (éléments comparables).
Programmation Orientée Objet – Java
21 septembre 2016
Types génériques et paramétrés
Structures de données Java
Implémentations de List<V> :
Bertrand Estellon (DII – AMU)
Bertrand Estellon (DII – AMU)
Types génériques et paramétrés
21 septembre 2016
126 / 171
▶
ArrayDeque<V> : Avec un tableau dynamique.
▶
LinkedList<V> : Avec une liste chaînée.
Bertrand Estellon (DII – AMU)
Programmation Orientée Objet – Java
21 septembre 2016
127 / 171