Atelier 1: Liste, Vector

III. Le langage JAVA Page
1
Page 1
Atelier 1: Liste, Vector, …
Cet atelier consiste à se familiariser avec les concepts généraux du langage Java à travers un cas d'école: la gestion
d'une liste d'éléments.
Nous verrons les 2 formes importantes d'implémentation : tableau ou vecteur. Nous introduirons les concepts de
généricité.
Cet atelier permettra de mettre en évidence: l'utilisation des packages et des exceptions.
I. La classe Liste
Sources: Ateliers/Atelier1/I_SimpleProgramme
Cette atelier correspond à l'écriture de la classe Liste avec son programme principal permettant de la tester, dans un
seul fichier, sans se préoccuper des notions d'éléments privées.
On y voit la création d'un menu tout à fait classique qui utilise les entrées sorties standards (clavier, écran) :
System.in et System.out.
II. L'encapsulation de la classe Liste (publique, privée)
Sources: Ateliers/Atelier1/II__ListeStatique
En Java, tant que toutes les classes sont sous le même répertoires, tous les éléments sont visibles. Les notions de
public et non public sont applicables dès que l'on crée des packages.
On crée 2 fichiers suivant l'arborescence suivante :
II_ListePackage/
packages/
utilitaires/
Liste.java
Programmes/
ListeP.java
Procédures de génération :
Dans Programmes/ javac -classpath "$CLASSPATH;..\packages" ListeP.java
Exécution :
Dans Programmes/ java -classpath "$CLASSPATH;.;..\packages" ListeP
III. Une classe Liste dynamique
Sources: Ateliers/Atelier1/III_ListeDynamique
Dans cette exemple, on se propose d'implémenter la liste sous la forme d'un simple chaînage de cellules contenant les
éléments de la liste. On appelle cela une liste dynamique car les éléments sont allouées au besoin et elle n'est pas
limité en taille.

III. Le langage JAVA Page
2
Page 2
Cette exemple permet de montrer la possibilité d'exécuter le même programme en utilisant l'un ou l'autre package:
cd ..\..\II_ListeStatique\Programmes
java -classpath "$CLASSPATH;.;..\..\III_ListeDynamique\packages" ListeP
IV. La liste statique avec les exceptions
Sources: Ateliers/Atelier1/IV_Exceptions
Dans cette correction, on se propose d'utiliser les exceptions pour tester les cas d'erreur.
Création de 4 fichiers:
ListeException.java
ListePleineException.java
ListeVideException.java
ListeDebordement.java
Fichier : ListeException.java :
package MonPackage;
public class ListeException extends Exception
{
public ListeException(String erreur)
{
super(erreur);
}
}
Fichier : ListePleineException.java :
package MonPackage;
import MonPackage.*;
public class ListePleineException extends ListeException
{
public ListePleineException(String erreur)
{
super(erreur);
}
}
Fichier : ListeVideException.java :
package MonPackage;
import MonPackage.*;
public class ListeVideException extends ListeException
{
public ListeVideException(String erreur)
{
super(erreur);
}
}
Fichier : ListeDebordement.java :
package MonPackage;

III. Le langage JAVA Page
3
Page 3
import MonPackage.*;
public class ListeDebordementException extends ListeException
{
public ListeDebordementException(String erreur)
{
super(erreur);
}
}
Dans le programme principal il faut rajouter:
public static void main(String args[]) throws IOException, ListeException
V. Une classe Liste générique
La liste définit précédemment ne permet de gérer que des éléments de type "String".
Pour pouvoir définir des éléments de type "quelconque", il faut que les traitements de la Liste soient génériques sur
les types d'élément.
Deux façons différentes :
 utilisation d'une classe abstraite
 utilisation d'une interface
I. Utilisation d'une classe générique
Sources: Ateliers/Atelier1/V.1_ListeGeneriqueAbstract
Une classe abstraite est une classe dont au moins une de ses méthodes est abstraite. On ne peut pas instancier une
classe abstraite (new) mais les classes qui en héritent utilisent les éléments de cette classe, comme une classe
normale.
Les méthodes abstraites d'une classe générique (ou asbtraite, même vocabulaire) doivent être impérativement être
toutes définies dans les classes héritantes.
Une méthode abstraite est une méthode dont on ne connaît que la signature et dont le corps est inconnu mais
dépendant de sa réelle utilisation.
Une classe générique est donc une définition générale d'une donnée, on appelle cela une donnée abstraite.
Le principe consiste à créer une classe générique appelée en Java abstract. Dans cette classe on définit les méthodes
génériques comme des méthode abstraites pour lesquelles, on définit que l'interface (pas de corps). Ensuite, on fait
hériter les classes pouvant être utilisées comme élément de la liste, de la classe générique. Il est alors obligatoire de
définir le corps des méthodes abstraites dans chacune de ces classes.
La classe Liste n'utilise que la classe abstraite pour traiter ses éléments.
On obtient l'arborescence d'héritage suivante :
 ObjetListe
 Individu
 Complexe
Les classes Individu et Complexe peuvent être utilisées comme type des éléments de la classe Liste.

III. Le langage JAVA Page
4
Page 4
II. Utilisation de la classe Object prédéfinie
Sources: Ateliers/Atelier1/V.2_ListeGeneriqueObject
Les traitements génériques de la classe abstraite précédente ObjetListe sont les méthodes toString et equals. Or ces
méthodes existent dans la classe Object.
En Java, il n'est pas obligatoire que les traitements génériques soient définis dans une classe générique. Toute
méthodes héritée peut être utilisée génériquement. Le langage Java est un langage objet à liaison dynamique. C'est à
dire que ce n'est qu'à l'exécution que le lien est fait entre la référence d'un traitement générique et le traitement réel.
Cela induit des erreurs possibles lors de l'exécution, Java ne trouvant pas dans une classe le traitement générique
utilisé.
Toutes les classes Java héritent par défaut de la classe prédéfinie Object. On peut donc corriger notre précédent
exemple en utilisant la référence de la classe Object dans la classe Liste, uniquement et tout simplement.
Par contre, si on veut définir des traitements génériques supplémentaires qui ne sont pas définis dans la classe
Object, il indispensable de ne pas se limiter à la classe Object car il est impossible de compléter la classe Object
(nous n'avons pas les sources des APIs de Java). De toute façon, cette solution ne serait pas acceptable: on ne peut
pas changer la classe Object à chaque fois que l'on définit des traitements génériques.
Il faut donc trouver un autre moyen aussi efficace mais plus simple que la création de classe abstraite.
D'autant plus que l'on ne peut pas hériter à la fois de 2 classes abstraites, Java ne pratique pas l'héritage multiple des
classes.
Par contre, il existe la notion d'interface. Une classe Java peut utiliser autant d'interface que nécessaire et peut
implémenter autant d'interface que nécessaire. De plus, les interfaces comme les classes peuvent s'hériter les unes des
autres.
III. Utilisation d'une interface Java
Une interface Java permet de déclarer des prototypes de méthodes. Elle définit un nom d'interface qui peut être
utilisé pour créer des références d'objet Java. Ces références ne sont pas créées par instanciation (new) mais par
conversion de classe.
Dans notre cas, au lieu d'utiliser la méthode equals pour comparer si deux éléments sont identiques, on veut utiliser
une méthode de nom comparer. Cette méthode n'existant pas dans la classe Object, on l'a défini dans l'interface
InterfaceListe.
Sources: Ateliers/Atelier1/V.3_ListeGeneriqueInterface
Une interface, à l'opposé d'une classe abstraite, ne peut pas contenir d'attribut mais que des prototypes de méthodes.
VI. La dérivation de la classe Liste
La classe que l'on veut créer est une classe de liste d'éléments générique dont les éléments sont uniques (suivant une
méthode de comparaison spécifique à chaque type d'élément) et toujours ordonnés.
Pour cela, on crée une classe qui hérite de la classe Liste. On redéfinit la méthode addElement pour tester l'unicité et
on crée la méthode trier afin de trier les éléments. On crée une nouvelle interface dans laquelle on définit la méthode
compareTo qui retourne 0 si deux éléments sont uniques, -1 si ils ont inférieurs et +1 si ils sont supérieurs.
On appelle cette classe Ensemble.
Sources: Ateliers/Atelier1/VI_Ensemble
Il a fallu modifier la classe Liste pour définir la méthode setElementAt qui permet de changer un élément de la liste.

III. Le langage JAVA Page
5
Page 5
On ajoute aux classes Individu et Complexe , la méthode compareTo de l'interface InterfaceEnsemble.
On définit le package Package2 dans lequel on définit la classe Ensemble.
VII. L'utilisation de la classe Vector
La classe Vector est une classe du package util du langage Java. Cette classe représente une liste d'élément de type
Object. Elle permet de stocker des éléments de toute classe (toutes les classes héritent de Object).
La correction qui suit consiste à ne pas créer la classe Liste mais à utiliser la classe prédéfinie vector.
Sources: Ateliers/Atelier1/VII_EnsembleVector
On définit alors les classes Individu et Complexe dans le même package: package2.
On a remplacé la méthode nb() par la méthode équivalente size() de Vector.
Explications en cours.