Programmation orientée objet

Langage Java

Sonia Kefi

2ème LI
Année Universitaire : 2024-2025
 Les objectifs

✓ Collections

✓ Maps

✓ Utilitaires :
• trier une collection
• parcourir une collection
• chercher une information dans une liste triée

2
 Rappel sur l’héritage
EtreHumain
• L'héritage multiple, une
Herbivore Carnivore
classe peut hériter en même
temps de plusieurs super
classes.
Lapin Homme Lion

Ce mécanisme n'existe pas en Java!!

Solution : Les interfaces

3
 Interface : Présentation

• Une interface est un modèle pour une classe

• Une interface est un ensemble de déclarations de

méthodes abstraites.

• Les interfaces ressemblent aux classes abstraites car

elles contiennent des méthodes expliquant certains
comportements sans les implémenter.
4
 Interface : Présentation
«interface»
Frome
«interface»
Dessinable caclulSurface()
dessiner(Graphics g) effacer(g: Graphics)
effacer(Graphics g)

Triangle Cercle
Int x, y; Int d,r;
dessiner(Graphics g) dessiner(Graphics g)
effacer(Graphics g) effacer(g: Graphics g)

• Toutes les classes qui implémentent cette interface possèdent les méthodes
et les constantes déclarées dans celle-ci.
• Plusieurs interfaces peuvent être implémentées dans une même classe.
5
 Héritage d’interfaces

• De la même manière qu'une classe peut avoir des sous-classes,

une interface peut avoir des "sous-interfaces".
• Une sous-interface :
– Hérite toutes les méthodes abstraites et des constantes de sa « super-
interface ».
– Peut contenir de nouvelles constantes et méthodes abstraites.

6
 Héritage d’interfaces

• A la différence des classes, une interface peut étendre plus d'une

interface à la fois.

7
Les Collections
 Collections : Présentation

• Une collection est un objet qui contient d'autres objets.

• Ces objets proposent une solution au stockage de données

et permettent de faire des manipulations.

• Les classes et les interfaces se trouvent dans le package :

java.util.

9
 Avantages

• Les collections permettent de :

- Améliorer la qualité et la performance des applications.
- Gérer un ensemble d'objets de types différents.
• Les collections sont utilisées pour :
- stocker, rechercher et manipuler des données.
- transmettre des données d’une méthode à une autre.
• Exemples :
- un dossier de courrier : collection de mails
- un répertoire téléphonique : collection de noms et de numéros de
téléphone.

10
 Collections : Architecture

• Elle est composée de 3 parties :

– Une hiérarchie d'interfaces permettant de représenter les

collections sous forme de types abstraits.

– Des implémentations de ces interfaces.

– Implémentation de méthodes liées aux collections (recherche,

tri, etc.).
11
Collections : Architecture

12
 Collections : Hiérarchie

• Deux hiérarchies principales :

– Collection

– Map : collections indexées

par des clés

13
 Collections : Implémentation
• Le framework fournit les implémentations suivantes des
différentes interfaces:

• Il n'y a pas d'implémentation de l'interface Collection. Pour Set et Map

l'implémentation est soit sous la forme d'une table de hachage
(HashSet/HashMap) ou bien sous la forme d'un arbre
(TreeSet/TreeMap).
• Pour la liste: soit sous la forme de tableau (ArrayList) ou une liste
chaînée (LinkedList). 14
 Interface Collection

• Un objet qui est un groupe d'objets.

• Principales méthodes :

boolean add(Object obj)

boolean contains(Object obj)
boolean containsAll(Collection collection)
Iterator iterator()
int size()
Object[] toArray()
Object[] toArray(Object[] tableau)
15
Interface Collection

16
SET
 Set<E>

• Set : est un ensemble ne contenant que des valeurs et ces valeurs ne sont
pas dupliquées.

Par exemple : l'ensemble A = {1,2,4,8}. Set hérite donc de Collection, mais

n'autorise pas la duplication.

• Un ensemble (Set) est une collection qui n'autorise pas l'insertion de

doublons.

• SortedSet est un Set trié.

18
Exemple

SetTrie

//Afficher par ordre alphabétique

19
 Set<E>

• Méthodes de Set<E>
– La méthode add n’ajoute pas un élément si un élément égal est déjà dans l’ensemble.
• Set : TreeSet et HashSet
• C'est une interface identique à celle de Collection. Deux implémentations
possibles:
– TreeSet : les éléments sont rangés de manière ascendante (triés).
– HashSet : les éléments sont rangés suivant une méthode de hachage
• Le choix entre ces deux objets est lié à la nécessité de trier les éléments :
– les éléments d'un objet HashSet ne sont pas triés : l'insertion d'un nouvel élément est
rapide.
– les éléments d'un objet TreeSet sont triés : l'insertion d'un nouvel élément est plus long.

20
 Classe HashSet<E>

• Cette classe est un ensemble d’élément sans ordre de tri

particulier.

• Les éléments sont stockés dans une table de hashage : cette

table possède une capacité.

21
 Classe HashSet<E>
import java.util.*;
public class TestHashSet {
public static void main(String args[]) {
Set set = new HashSet();
set.add("CCCCC");
set.add("BBBBB");
set.add("DDDDD");
set.add("BBBBB");
set.add("AAAAA");
Iterator iterator = set.iterator();
while (iterator.hasNext()) {System.out.println(iterator.next());}
}
}

Resultat : {CCCCC, BBBBB, DDDDD, AAAAA }

22
 Classe TreeSet <E>

• Cette classe est un arbre qui représente un ensemble trié d'éléments.

• L'insertion d'un nouvel élément dans un objet de la classe TreeSet est donc
plus lent mais le tri est directement effectué.

23
 Classe TreeSet<E>
import java.util.*;
public class TestHashSet {
public static void main(String args[]) {
Set ts = new TreeSet();
ts.add("one");
ts.add("two");
ts.add("three");
ts.add("four");
ts.add("three");
System.out.println("TreeSet = " + ts);
}
}

Resultat : TreeSet = [four, one, three, two]

24
Interface qui hérite
de l’interface Set
 Interface SortedSet

• Cette interface définit une collection de type ensemble trié par un

comparateur.
• Elle hérite de l'interface Set.
• Définit les méthodes suivantes :

✓ Comparator<E> comparator() : Renvoie le comparateur utilisé pour définir l'ordre

✓ E first(), last() : Renvoie le premier/dernier élément
✓ Très peu utiliser car SortedSet ne définie pas assez de méthodes et ne possédait
qu'une implémentation TreeSet

26
Interface List
 Interface List
• Elle hérite aussi de collection, mais elle autorise la
duplication.
• Dans cette interface, un système d'indexation a été
introduit pour permettre l'accès (rapide) aux éléments de
la liste.

28
Exemple

29
 Les méthodes de l'interface List

• Les méthodes de l'interface List permettent d'agir sur un élément

se trouvant à un index donné ou bien un ensemble d'éléments à
partir d'un index donné dans la liste.
• get (remove) retourne (ou retirer) l'élément se trouvant à la
position index.
• set (add & addAll) modifie (ou ajouter) l'élément (un seul ou une
collection) se trouvant à la position index.
• indexOf (lastIndexOf) recherche si un objet se trouve dans la liste
et retourner son (ou son dernier) index.
• subList permet de créer un sous-liste d'une liste.
30
31
 Parcours de la Liste
• Pour parcourir une liste, il a été défini un itérateur spécialement
pour la liste.

32
 Parcours de la Liste

• Cet Itérateur permet de parcourir la liste dans les deux directions

et de modifier un élément (set) ou d'ajouter un nouveau élément :

• hasNext permet de vérifier s'il y a un élément qui suit.

• next permet de pointer l'élément suivant.
• nextIndex retourne l'index de l'élément suivant.

33
 Exemple
import java.util.*;
public class Example {
public static void main(String args[]) {
// Create a new ArrayList
ArrayList L= new ArrayList();
// Add some items to the ArrayList
L.add(1);
L.add(2);
L.add(3);
L.add(4);
L.add(5);
Iterator i = L.iterator();
// Loop through ArrayList contents
while(i.hasNext()) {
Object item = i.next();
System.out.print(item + ", ");
34
} }}
Autres opérations sur la
collection

• Tri
• Recherche dans une
collection
 Collection

• Cette classe ne contient que des méthodes static,

utilitaires pour travailler avec des collections :

– Parcours d’une collection : Iterator

– Trie (sur listes)
– Recherche (sur listes)
– Copie
– Recherche du minimum et maximum

36
 Interface ITERATOR<E>
• En Java, la classe Iterator fait partie de l'interface java.util.Iterator.
• Elle est utilisée pour parcourir les éléments d'une collection (par exemple,
une liste, un ensemble, etc.) de manière séquentielle sans présenter les
détails internes de la collection.
• L'interface Iterator contient les méthodes suivantes :

public interface Iterator {

boolean hasNext(); //Permet de vérifier s'il y a un élément qui suit
Object next(); //Permet de pointer sur l'élément suivant
void remove(); //Permet de retirer l'élément courant
}

37
 Fonctionnalités principales de l'interface
Iterator
• L'interface Iterator définit trois méthodes principales :

• hasNext() : Vérifie s'il reste des éléments à parcourir dans la collection.

Retourne true si un autre élément est disponible, sinon false.

• next() : Retourne l'élément suivant de la collection. Si aucun élément n'est

disponible, elle lève une exception NoSuchElementException.

• remove() : Supprime le dernier élément retourné par next() de la collection.

Si l'opération n'est pas prise en charge, elle lève une exception
UnsupportedOperationException.
38
 Exemple

Le résultat attendu est : Éléments de la liste :

10
20
30 39
Liste après suppression : [10, 30]
 Schéma explicatif
• Voici l'état de l'itérateur à chaque étape pour la liste [10, 20, 30]:

•Avant le début de la boucle : Lorsque vous obtenez un itérateur avec iterator() :

–L'itérateur est positionné avant le premier élément de la liste. Il ne pointe sur aucun élément.
•Lors du premier appel à hasNext():
–La méthode vérifie si la liste contient au moins un élément après la position actuelle.
–Si c'est le cas (c'est-à-dire si la collection n'est pas vide), elle retourne true
.

•Lors du premier appel à next():

–L'itérateur passe au premier élément de la liste et le retourne.
40
 Le Tri

• Afin de trier une liste :

Collections.sort(l);

• Pour que la liste soit correctement triée, il faut que les éléments
de la liste soient comparables.
• Plus exactement, la méthode sort() ne fonctionnera que si tous
les éléments de la liste sont d’une classe qui implante l’interface
prédéfinie :
Comparable<T>
41
 Interface Comparable<T>
• Cette interface utilise un ordre naturel dans les instances d’une classe.
• L’interface est présente dans le package java.lang.
• L'interface Comparable est utile lorsqu’on veut définir un ordre par défaut
pour les objets.
• Par exemple, dans le cas des objets Person, on veut définir un ordre basé
sur le nom.
• Les éléments sont comparables par un ordre usuel, par exemple :
– Byte, Short, Integer, Long, Float, Double, BigInteger et BigDecimal: Ordre numérique
signé.
– Char (caractère): Ordre numérique non signé (donc alphabétique).
– File: Ordre lexicographique sur le chemin d'accès.
– String: Ordre lexicographique.
– Date: Ordre chronologique. 42
 Interface Comparable<T>

• L'interface Comparable déclare une seule méthode pour trier les éléments
en Java, nommée :

int compareTo(Object o);

• On redéfinie la méthode :
public int compareTo (Object o) avec :

– a.compareTo (b) == 0 si a.equalsTo(b)

– a.compareTo (b) < 0 si a plus « petit » que b
– a.compareTo (b) > 0 si a plus « grand » que b
43
Exemple de Comparable

44
Interface Map
 Interface Map

<<interface>> <<abstract>>
Map<K, V> AbstractMap<K, V>

<<interface>>
SortedMap <K, V> TreeMap<K, V> HashMap<K, V>

46
 Interface Map
• L’interface Map<K,V> correspond à un groupe de couples clés-valeurs.

• La clé est unique, contrairement à la valeur qui peut être associée à

plusieurs clés (dans la map, il ne peut pas exister 2 clés égales).

• Les deux classes qui implémentent cette interface sont :

– HashMap<K,V>, table de hachage ; garantit un accès en temps constant.

– TreeMap<K,V>, arbre ordonné suivant les valeurs des clés avec accès en log(n) ;

• La comparaison utilise l’ordre naturel (interface Comparable<K>) ou une

instance de Comparator<K>.
47
Exemple de méthodes

48
 Interface Map : Les méthodes

• Object put(K clé, V valeur) • ajouter et enlever des couples clé – valeur
• void putAll(Map<K,V>map)
• void remove(Object key)
• boolean containsKey(Object clé) • vérifier si une table contient une clé
• boolean containsValue(Object valeur) • vérifier si une table contient une valeur
• Set<Map.Entry<K,V>> entrySet()
• V get(Object clé) • récupérer une référence à un des
• boolean isEmpty() éléments donnant sa clé
• Set<K> keySet() • récupérer les clés
• int size() • récupérer la taille
• Collection<V> values() • récupérer les valeurs

49
 Interface Map : Récupération des données

keySet()
Récupérer les clés sous forme de Set<K> avec la méthode iterator()

values() Récupère les valeurs sous forme de Collection<V> avec la méthode

iterator()

Récupère les entrées (clé-valeur) sous forme de Set<Entry<K,V>>

entrySet() avec la méthode iterator()

50
 Interface Map : Map.Entry<K,V>

• L’interface Map contient l’interface interne public Map.Entry<K,V>

qui correspond à un couple clé-valeur.

• Cette interface contient 3 méthodes :

K getKey()
V getValue()
V setValue(V valeur)

• La méthode entrySet() de Map renvoie un objet de type

« ensemble (Set) de Entry »
51
Interface Map : Les méthodes d’itération

// iterer sur les clés

for (Iterator i = m.keySet().iterator(); i.hasNext(); )
System.out.println(i.next());

// iterer sur les valeurs

for (Iterator i = m.values().iterator(); i.hasNext(); )
System.out.println(i.next());

// iterer sur la paire clé/valeur

for (Iterator i = m.keySet().iterator(); i.hasNext(); ) {
Map.Entry e = (Map.Entry) i.next();
System.out.println (e.getKey() + " ; " + e.getValue());
}
52
 HashMap et hashCode()

• La classe HashMap<K,V> utilise la structure informatique

nommée « table de hachage » pour ranger les clés.

• La méthode hashCode() est utilisée pour répartir les clés dans la

table de hachage.

– Deux objets identiques ont le même hashCode.

– Deux objets ayant le même hashCode ne sont pas forcément identiques.

53
 Exemple de la classe HashMap

Contenu de la HashMap : {Alice=25, Bob=30, Charlie=35}

Alice a 25 ans.
Après suppression de Bob : {Alice=25, Charlie=35}
Parcours de la HashMap :
Alice : 25
Charlie : 35 54
Taille de la HashMap : 2
 Explications

1.Création d'une HashMap :

•HashMap<String, Integer> signifie que les clés sont des String et les valeurs sont des Integer.
2.Méthodes principales utilisées :
•put(K key, V value) : Ajoute une paire clé-valeur dans la HashMap.
•get(Object key) : Récupère la valeur associée à une clé.
•containsKey(Object key) : Vérifie si une clé spécifique est présente.
•remove(Object key) : Supprime une paire clé-valeur.
•keySet() : Renvoie un ensemble des clés présentes dans la HashMap.
•size() : Retourne le nombre d'éléments dans la HashMap.
3.Parcours :
•Utilisation de keySet() pour parcourir les clés et accéder aux valeurs associées.

55
 Exemple de TreeMap

Contenu de la TreeMap : {Alice=25, Bob=30, Charlie=35, Diana=28}

Bob a 30 ans.
Après suppression de Charlie : {Alice=25, Bob=30, Diana=28}
Parcours de la TreeMap :
Alice : 25
Bob : 30
Diana : 28
Première clé : Alice
Dernière clé : Diana 56
 Explications

1.Création d'une TreeMap :

•La classe TreeMap trie automatiquement les clés.
•Les clés (String) seront triées par ordre alphabétique.
2.Méthodes principales utilisées :
•put(K key, V value) : Ajoute une paire clé-valeur.
•get(Object key) : Récupère la valeur associée à une clé.
•containsKey(Object key) : Vérifie si une clé existe.
•remove(Object key) : Supprime une paire clé-valeur.
•firstKey() et lastKey() : Renvoient respectivement la première et la dernière clé dans l'ordre.
3.Parcours :
•Utilisation de keySet() pour obtenir les clés triées.

57
To be continued !

58