« Encore un sujet fascinant. »

« On va de surprise en surprise ! C'est mon anniversaire ? »

« Aujourd'hui, je vais te parler des génériques. Les génériques sont des types qui ont un paramètre. En Java, les classes de conteneur te permettent d'indiquer le type de leurs objets internes. »

« Lorsque nous déclarons une variable générique, nous indiquons deux types au lieu d'un : le type de la variable et le type de données qu'elle stocke. »

« ArrayList constitue un bon exemple. Lorsque nous créons un nouvel objet ArrayList, il est commode d'indiquer le type des valeurs qui seront stockées à l'intérieur de cette liste. »

Code Explication 
ArrayList<String> liste = new ArrayList<String>();
 Crée une variable ArrayList appelée liste.
Et lui affecte un objet ArrayList.
Cette liste ne peut stocker que des objets String.		 
ArrayList liste = new ArrayList();
 Crée une variable ArrayList appelée liste.
Et lui affecte un objet ArrayList. Cette liste peut stocker toute valeur.		 
ArrayList<Integer> liste = new ArrayList<Integer>();
 Crée une variable ArrayList appelée liste.
Et lui affecte un objet ArrayList.
Cette liste ne peut stocker que des valeurs Integer et int.

« Ça m'a l'air super intéressant. Surtout la partie sur le stockage de valeurs de tout type. »

« Ça n'a l'air bien qu'en apparence. En réalité, si on met des chaînes dans une variable ArrayList dans une méthode, mais qu'on s'attend à ce qu'elle contienne des nombres dans une autre méthode, le programme plante (se termine par une erreur). »

« Je vois. »

« Pour l'instant, nous n'allons pas créer nos propres classes avec des paramètres de type. Nous allons simplement utiliser celles qui existent déjà. »

« Est-ce que toute classe peut être un paramètre de type, même celles que j'écris ? »

« Oui. Tous les types, sauf les types primitifs. Tous les paramètres de type doivent hériter de la classe Object. »

« Tu veux dire que je ne peux pas écrire ArrayList<int> ? »

« Exact, tu ne peux pas. Mais les développeurs de Java ont écrit des classes qui encapsulent chacun des types primitifs. Ces classes héritent d'Object. Voici comment ça se passe : »

Type primitif Classe Liste
int Integer ArrayList<Integer>
double Double ArrayList<Double>
boolean Boolean ArrayList<Boolean>
char Character ArrayList<Character>
byte Byte ArrayList<Byte>

« Tu peux facilement affecter les classes primitives et les classes qui les encapsulent entre elles : »

Exemples 
int a = 5;
Integer b = a;
int c = b;


Character c = 'c';  //Le littéral c est un char
char d = c;

Byte b = (byte) 77;  // Le littéral 77 est un int
 
Boolean toutVaBien = true;  // Le littéral true est un boolean
 
Double d = 1.0d;  // Le littéral 1.0d est un double

« Parfait. Je crois que je vais essayer d'utiliser ArrayList plus souvent. »