Programmation Objet avancée

Chapitre 1 : La généricité en java

Objectifs
 Comprendre la notion de Généricité en Java
 Comprendre et appliquer les classes et méthodes paramétrables
 Mettre en œuvre la généricité dans le cas d’un héritage

Prérequis
Notion de base de la programmation Objet java

Durée
1.5 heure

Contenu
 Généricité : principe de typage, usages
 Classes génériques et contraintes sur les types
 Implémentation de méthodes génériques
 Généricité et héritage

MHAFDHI Houda 4|Page

 Programmation Objet avancée

1. Les génériques en Java

Les génériques désignent des types paramétrés. Il s’agit de permettre au type (Integer, String…
etc, et types définis par l'utilisateur) d'être un paramètre pour les méthodes, les classes et les
interfaces. En utilisant les génériques, il est possible de créer des classes qui fonctionnent avec
différents types de données.
Une entité telle qu'une classe, une interface ou une méthode qui opère sur un type paramétré,
est appelée entité générique.
Object est la superclasse de toutes les autres classes et la référence d’Object peut faire
référence à n'importe quel type d'objet. Ces caractéristiques manquent de sécurité de
type. Les Generics ajoute cette fonction de sécurité de type.

2. Les classes génériques

On utilise < > pour spécifier les types de paramètres dans la création de classe générique. Pour
créer des objets de classe générique, nous utilisons la syntaxe suivante.
 Pour créer une instance d’une classe générique

BaseType <Type> obj = new BaseType

<Type>()
Note : Dans le paramètre type, on ne peut pas utiliser des types primitifs telles que 'int', 'char'
ou 'double'.
Exemple 1

class Test<T>
{ // on va déclarer un objet de type T
T obj;
Test(T obj) { this.obj = obj; } // constructeur
public T getObject() { return this.obj; }
}

MHAFDHI Houda 5|Page

Programmation Objet avancée

class Main
{ public static void main (String[] args)
{
// instance de type integer
Test <Integer> iObj = new Test<Integer>(15);
System.out.println(iObj.getObject());

// instance de type String

Test <String> sObj = new Test<String>("GeeksForGeeks");
System.out.println(sObj.getObject());
}
}

Exemple 2 : Programme avec deux types de paramètres

class Test<T, U>

{
T obj1; // un objet de type T
U obj2; // un objet of type U

Test(T obj1, U obj2)

{
this.obj1 = obj1;
this.obj2 = obj2;
}
// affiche les objets de type T et U
public void print()
{
System.out.println(obj1);
System.out.println(obj2);
}}

class Main
{ public static void main (String[] args)
{
Test <String, Integer> obj =
new Test<String, Integer>("GfG", 15);

obj.print();
}}

MHAFDHI Houda 6|Page

 Programmation Objet avancée

3. Les fonctions génériques

Nous pouvons également écrire des fonctions génériques qui peuvent être appelées avec
différents types d'arguments en fonction du type d'arguments passés à la méthode générique, le
compilateur gère chaque méthode[1].

Exemple

class Test
{
// exemple de méthode générique
static <T> void genericDisplay (T element)
{
System.out.println(element.getClass().getName() +
" = " + element);
}

// Driver method
public static void main(String[] args)
{
// appel de la méthode générique avec un argument integer
genericDisplay(11);

// appel de la méthode générique avec un argument String

genericDisplay("GeeksForGeeks");

// appel de la méthode générique avec un argument double

genericDisplay(1.0);
}
}

Output :
java.lang.Integer = 11
java.lang.String = GeeksForGeeks
java.lang.Double = 1.0

Remarques
1) Lorsque nous déclarons une instance de type générique, l'argument de type passé au
paramètre doit être un objet. Nous ne pouvons pas utiliser de types de données primitifs comme
int, char.,
Test<int> obj = new Test<int>(20);

MHAFDHI Houda 7|Page

Programmation Objet avancée

Ce code génère une erreur de compilation,

2) Les types génériques diffèrent en fonction de leurs arguments de type

Exemple

class Test<T>
{
T obj;
Test(T obj) { this.obj = obj; }
public T getObject() { return this.obj; }
}

class Main
{
public static void main (String[] args)
{
// instance de type Integer
Test <Integer> iObj = new Test<Integer>(15);
System.out.println(iObj.getObject());

// instance de type String

Test <String> sObj = new Test<String>("GeeksForGeeks");
System.out.println(sObj.getObject());
iObj = sObj;// ce code genere une erreur
}
}

Output:
Error :
incompatible types :
Test cannot be converted to Test
Même si iObj et sObj sont de type Test, ce sont des références à des types différents car leurs
paramètres sont de type diffèrent.

Exercice
La classe suivante [2] Tableau encapsule un tableau d'entiers et comporte deux méthodes
permettant de trier le tableau et d'afficher son contenu. La méthode main de cette classe fournit
un exemple d'utilisation. On voudrait disposer d'une méthode de tri pour n'importe quel type de
tableau. Proposez une solution basée sur la généricité.

MHAFDHI Houda 8|Page

Programmation Objet avancée

public class Tableau

{
private int T [];
public Tableau (int T []){this.T = T;} // on fait ici une recopie "superficielle"
public void triBulles ()
{int i = T.length -2;
boolean ech = true;
while (i >=2 && ech)
{ech = false;
for (int j = 0; j <= i; j ++)
if (T[j] > T[j+1])
{ int aux = T[j];
T[j] = T[j+1];
T[j+1] = aux;
ech = true; }
i--;
}}
“
public void affiche ()
{for(int i = 0; i < T.length; i++)
System.out.print(T[i]+" ");
System.out.println();
}
public static void main(String[] args)
{
int T[] = {10,2,6,11, 7, 2, -1, 0, 9};
Tableau obj = new Tableau(T);
obj.trieBulles();obj.affiche();}}

4. L’héritage et la généricité
Une classe générique [3]peut agir comme une superclasse ou être une sous-classe. Dans une
hiérarchie, tous les arguments type nécessaires à une superclasse générique doivent être
transmis dans la hiérarchie par toutes les sous-classes.
Il faut suivre certaines règles lors de la création d’une classe générique en tant que superclasse
ou sous-classe.
1- Une classe générique peut hériter une classe non générique.

MHAFDHI Houda 9|Page

Programmation Objet avancée

class NonGeneric
{
//Classe non générique
}
class Generic<T> extends NonGeneric
{
//Classe générique hérite une classe non générique
}

2- Une classe générique peut également hériter une autre classe générique. Lorsqu’une classe
générique hérite une autre classe générique, la sous-classe doit avoir au moins le même type et
le même nombre de paramètres type.
class A<T>
{
//Superclasse générique avec un seul type
}
class B<T> extends A<T>
{
//Sous-classe avec le même type
}
class C<T, E> extends A<T>
{
//Sous-classe avec deux types
}
class D<K, V> extends A<T>
{
//Erreur de compilation, sous-classe ayant différents types
}

3- Lorsqu’une classe générique hérite une autre classe générique, les types sont passés de la
sous-classe à la super-classe comme dans le cas du chaînage de constructeur où le constructeur
de la super-classe est appelé par le constructeur de la sous-classe en passant les arguments
requis.
Par exemple, dans le programme ci-dessous, « T » dans « A » sera remplacé par String.

MHAFDHI Houda 10 | P a g e
Programmation Objet avancée

class A<T>
{
T var;
public A(T var)
{
this.var = var;
}
}
class B<T> extends A<T>
{
public B(T var)
{
super(var);
}
}
public class Main
{
public static void main(String[] args)
{
B<String> b = new B<String>("WayToLearnX");
System.out.println(b.var);
}
}

MHAFDHI Houda 11 | P a g e