ING3 POO Java

COURS 4
1. POLYMORPHISME - CLASSES ABSTRAITES - INTERFACE ...........................................................................................2 1
1.1. Polymorphisme............................................................................................................................................... 2
1.2. Classes abstraites .............................................................................................................................................. 4
1.3. Non-respect du principe de substitution .......................................................................................................... 7
1.4. Classe interface .............................................................................................................................................. 8
1.5. Quelques écueils à éviter .................................................................................................................................. 11
1.6. Ressources en ligne sur campus ....................................................................................................................... 12
2. LES COLLECTIONS ........................................................................................................................................................... 13
2.1 Les types de Collections....................................................................................................................................... 13
2.2 L’interface Collection .............................................................................................................................................. 16
2.3. La collection List .................................................................................................................................................... 17
2.4. L’interface Map ....................................................................................................................................................... 18
2.5. L’implémentation de Map ...................................................................................................................................... 21
2.6. L’implémentation de List ....................................................................................................................................... 22
2.7. Trier sa collection ................................................................................................................................................... 23

POO Java – Cours 4 JP Segado

 ING3 POO Java
1. POLYMORPHISME - CLASSES ABSTRAITES - INTERFACE

2
1.1. Polymorphisme

Le polymorphisme consiste à découpler le quoi du comment au niveau des types (classes) : on crée une super-classe pour définir
l'interface et plusieurs sous-classes pour définir des implémentations différentes

Rappel : Upcasting nous permet de traiter sans distinction toutes les sous-classes d'une même superclasse.

 Le polymorphisme utilise des upcast pour permettre à un programme de "oublier" intentionnellement le type précis d'un
objet.

 Cela réduit la complexité en éliminant le besoin d'un traitement spécial de chaque type différent.

 Le constructeur de sa super-classe est appelé.

 Cette étape est répétée récursivement jusqu'à ce que la racine de la hiérarchie soit construite d'abord, suivie par la
sous-classe suivante, etc, jusqu'à ré-atteindre la sous-classe;

 Les constructeurs des membres sont appelés dans l'ordre de déclaration;

 le corps du constructeur de la classe est appelée.

POO Java – Cours 4 JP Segado

 ING3 POO Java
Exemples sans polymorphisme :
public class Note {
public final int MIDDLE_C = 0;
public final int C_SHARP = 1; 3
}
public class Music2 {
public class Instrument {
public static void tune(Wind i) {
public void play(int note) { i.play(Note.MIDDLE_C);
System.out.println("Instrument.play()"); }
} public static void tune(Stringed i) {
} i.play(Note.MIDDLE_C);
}
public class Wind extends Instrument { public static void tune(Brass i) {
public void play(int note) { i.play(Note.MIDDLE_C);
System.out.println("Wind.play()"); }
} public static void main(String[] args) {
} Wind flute = new Wind();
Stringed violin = new Stringed();
public class Stringed extends Instrument { Brass frenchHorn = new Brass();
public void play(int note) { tune(flute); // Pas d'upcast
tune(violin);
System.out.println("Stringed.play()");
tune(frenchHorn);
}
}
}
}
public class Brass extends Instrument {
public void play(int note) {
System.out.println("Brass.play()");
}
}

POO Java – Cours 4 JP Segado

 ING3 POO Java
Exemple avec polymorphisme :

Redéfinissons la méthode tune () avec un argument un objet de type Instrument :

4
public static void tune(Instrument i) { // argument polymorphe
i.play(Note.MIDDLE_C); // appel polymorphe
}

Mécanisme d’association tardive (late- or dynamic-binding) qui lors de l'exécution,

choisit la bonne méthode play () à utiliser à base du type spécifique de l'objet - pas le
type de la référence

1.2. Classes abstraites

 Une classe abstraite est une classe qui ne peut être instanciée.

 Une classe abstraite est utilisée dans des situations particulières dans le cadre de l’héritage

 les sous-classes forment une couverture de la classe abstraite

Exemple :

Commentaires :
- les personnels d'un lycée sont soit des enseignants soit des administratifs soit
des personnels de service.
- Les trois sous-classes "couvrent" l'ensemble des personnels.

POO Java – Cours 4 JP Segado

 ING3 POO Java

 La classe abstraite ne contient pas suffisamment d'informations pour instancier un objet.

 Autrement dit cette classe n'est présente que pour factoriser des propriétés. 5

 Il s'agit souvent de classes qui modélisent un concept.

 On utilise le mot clé abstract

 Pour signaler qu'une méthode ou une classe est incomplète et qu'elle ne peut pas être instanciée.

Syntaxe partielle :
abstract class nomsuperclasse
{
// méthode abstraite pure sans corps
public abstract type nomméthode(…) ;
}

Exemple : la classe Personnels ci-dessous est abstraite.

abstract class Personnels { public abstract void travailler(int heures) ; }

POO Java – Cours 4 JP Segado

 ING3 POO Java
 Une méthode abstract ne définit pas de corps de méthode.

 Une classe contenant une ou plusieurs méthodes abstract doit également être déclarée abstract. 6

 Toute classe qui hérite d'une classe abstract doit implémenter les corps des méthodes abstract, ou se déclarer elle-
même abstract.

 Une classe abstract ne peut pas être instanciée.

Exemple : les classes héritières de Personnels peuvent implémenter sa méthode abstract.

public class Enseignants extends Personnels {

public void travailler(int heures) {
System.out.println(″nombre d’heures de cours = ″+heures);
}
}

POO Java – Cours 4 JP Segado

 ING3 POO Java
1.3. Non-respect du principe de substitution

Le principe de substitution a été énoncé en 1987 par B. Liskow : " Toute instance d'une sous-classe peut être remplacée par une
7
instance d'une super-classe sans modification de sémantique ". Autrement dit, si la classe B spécialise une classe A, un objet b de B
doit trouver un intérêt dans toutes les opérations de A.

Exemple :

Imaginons que nous disposions d'une classe Liste qui fournit les opérations suivantes :

Si nous devons implémenter une pile, il serait tentant de faire :

Mais dans cette hypothèse la pile est dénaturée puisqu'elle va

bénéficier d'opérations qui ne concernent pas une telle
structure de données.

POO Java – Cours 4 JP Segado

 ING3 POO Java
Il est préférable de faire :

Ainsi, chaque instance de Pile va comporter une instance de Liste, 8

l'utilisateur n'aura accès qu'aux deux opérations Empiler et Dépiler. La
pile délègue ses opérations à la liste.

1.4. Classe interface

 Une classe interface est constituée d'opérations non décrites servant à définir un service particulier d'une classe.
Par exemple : une classe Personne peut réaliser plusieurs interfaces : un client, un employé, un sportif.

 Seules des signatures

de méthodes sont présentes
dans les interfaces. L'interface
indique un contrat (une
promesse).

 La définition des
méthodes se trouvent dans la
classe qui réalise l'interface.
On parle souvent de liaison
retardée.

POO Java – Cours 4 JP Segado

 ING3 POO Java
 La notion d'interface permet de mettre en œuvre l'héritage multiple pour des langages qui ne le supporte pas.

 La notion d'interface est très puissante en conception objet, sa mise en œuvre permet de diminuer le couplage entre 9
les classes en faisant collaborer des classes avec seulement des services nécessaires.

Pour créer une interface, on utilise le mot-clé interface à la place du mot clé class.
Le mot-clé interface produit une classe complètement abstraite, qui ne fournit absolument aucune implémentation.

– Définit des méthodes implicitement abstract et public

– Des données implicitement static et final

Syntaxe partielle :

interface nomInterface
{
… // signature des méthodes sans corps
}

 Une interface déclare "Voici ce à quoi ressemblera toutes les classes qui implémenteront cette interface."

 Ainsi, tout code utilisant une interface sait quelles méthodes peuvent être appelées pour cette interface.

 Une interface est donc utilisée pour établir un "protocole" entre les classes.

POO Java – Cours 4 JP Segado

 ING3 POO Java
Le mot-clé implements permet de rendre une classe conforme à une interface (ou groupe d'interfaces).
Il déclare que les méthodes de l'interface seront toutes implémentées.
Les méthodes d'une interface sont implicitement public, donc les implémentations doit l'être aussi. Les interfaces sont utilisées
pour implémenter une forme d'héritage multiple, en créant une classe qui peut être transtypée en plus d'une super-classe. 10

Syntaxe partielle :
public class nomclasse implements nomInterface1,…,nomInterfacen
{ ... // implémenter toutes les méthodes des interfaces avec leur corps =}

Exemple en Java : reprenons l’exemple du diagramme de classes précédent

interface Client {
public void commander();
public void acheter();
}

interface Employe {
public void travailler();
}

interface Sportif {
public void jouer();
}

public class Personne implements Client, Employe, Sportif {

// implémenter toutes les méthodes des interfaces
public void commander () {...}
public void acheter() {...}
public void travailler() {...}
public void jouer() {...}
}

POO Java – Cours 4 JP Segado

 ING3 POO Java
1.5. Quelques écueils à éviter

 La généralisation est un élément décisif du monde objet. 11

 Son utilisation sans règle n'est pas sans risque, nous pointons ici quelques erreurs dues à une généralisation non
maîtrisée.

 Hétérogénéité des sous-classes de même niveau

Le critère de construction des deux classes spécialisées Salarié et Libéral

est la profession, par contre la classe Sportif relève d'une toute autre
classification. Le comportement spécialisé du salarié ou du libéral ne
pourrait bénéficier au sportif.

Il est préférable de faire :

POO Java – Cours 4 JP Segado

 ING3 POO Java
 Confusion de niveau d'abstraction
Ici, la classe spécialisée ne relève pas du même niveau d'abstraction ; le
modèle de voiture rend compte d'un concept, la voiture d'une identité physique. 12
La spécialisation ne convient pas; celle-ci ne doit pas être justifiée
uniquement par la factorisation de propriétés -c'est le cas ici- mais elle doit
aussi relever d'un même niveau d'abstraction. La classe Modèle de voiture peut
être vue comme une "méta-classe" - type de voiture- alors que la classe
Voiture doit être perçue comme une classe "physique".

La théorie des ensembles fournit un substrat à la notion de généralisation.

Dans cette hypothèse, une classe spécialisée représente un sous ensemble -par valeur- de la super-classe ; ce n'est pas le cas dans
cet exemple, il y a beaucoup plus de voitures que de modèles de voiture.

Le modèle conforme serait :

1.6. Ressources en ligne sur campus

 Site du cours POO Java

Les bienfaits de l'héritage

Héritage, polymorphisme, interface

POO Java – Cours 4 JP Segado

 ING3 POO Java
2. LES COLLECTIONS

2.1 Les types de Collections 13

Le Collections présente un ensemble de conteneurs génériques pour stocker vos objets.

 L'API définit:
 Un ensemble d’interfaces décrivant le comportement abstrait des différents types de conteneurs ;
 Plusieurs implémentations de ces interfaces, chacun optimisant un aspect différent de son conteneur ;
 Des classes et interfaces utilitaires pour gérer une collection.

 L'API est largement suffisante pour la plupart de nos utilisations, mais reste ouvert et extensible.

POO Java – Cours 4 JP Segado

 ING3 POO Java

Principales interfaces 14

Implémentations

POO Java – Cours 4 JP Segado

 ING3 POO Java

15

Classes et interfaces utilitaires

 Interfaces utilitaires
 Comparator https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

 Iterator https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html

 Classes utilitaires
 Collections https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html
 Arrays https://docs.oracle.com/javase/8/docs/api/java/util/Arrays.html

POO Java – Cours 4 JP Segado

 ING3 POO Java
2.2 L’interface Collection
https://docs.oracle.com/javase/8/docs/api/java/util/Collection.html
16
 Abstraction du comportement d'un conteneur d'objets

 Quelques méthodes :
Modifier and Type Method and Description

boolean add(E e) Ensures that this collection contains the specified element (optional operation).
boolean addAll(Collection<? extends E> c) Adds all of the elements in the specified collection to this collection (optional operation).
void clear() Removes all of the elements from this collection (optional operation).
boolean contains(Object o)
Returns true if this collection contains the specified element.
boolean equals(Object o)
Compares the specified object with this collection for equality.
boolean isEmpty()
Returns true if this collection contains no elements.
Iterator<E> iterator()
Returns an iterator over the elements in this collection.
boolean remove(Object o)
Removes a single instance of the specified element from this collection, if it is present (optional operation).
boolean removeAll(Collection<?> c)
Removes all of this collection's elements that are also contained in the specified collection (optional operation).
int size()
Returns the number of elements in this collection.
Object[] toArray()
Returns an array containing all of the elements in this collection.
Les méthodes qui comparent les objets, telles que contains(), testent l'égalité du contenu des objets avec equals(..), et pas
l'égalité des références.

POO Java – Cours 4 JP Segado

 ING3 POO Java
2.3. La collection List

https://docs.oracle.com/javase/8/docs/api/java/util/List.html
17
interface List extends Collection

 Une collection ordonnée d'objets

 Doublons acceptés

 Quelques méthodes :

Modifier and Type Method and Description

boolean add(E e)
Appends the specified element to the end of this list (optional operation).
E get(int index)
Returns the element at the specified position in this list.

int int indexOf(Object o)

Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain
the element.

boolean isEmpty()
Returns true if this list contains no elements.
E remove(int index)
Removes the element at the specified position in this list (optional operation).
 Implémentations:
 ArrayList, LinkedList Exemples avec la classe ArrayList

POO Java – Cours 4 JP Segado

 ING3 POO Java
2.4. L’interface Map

https://docs.oracle.com/javase/8/docs/api/java/util/Map.html
18

interface Map // n’hérite pas de Collection

 Une structure qui associe clefs uniques (keys) à des valeurs (values)

 Un tableau associatif

 Remplace l'interface java.util.Dictionary de Java1.1

 Pour fonctionner correctement, les objets utilisés comme clefs doivent redéfinir Object.hashCode()

 Implémentations:

 HashMap, Hashtable, WeakHashMap, Attributes

POO Java – Cours 4 JP Segado

 ING3 POO Java
 Quelques méthodes:
Modifier and Type Method and Description

clear() 19
void
Removes all of the mappings from this map (optional operation).
boolean containsKey(Object key)
Returns true if this map contains a mapping for the specified key.
boolean containsValue(Object value)
Returns true if this map maps one or more keys to the specified value.
boolean equals(Object o)
Compares the specified object with this map for equality.
<< get(Object key)
Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.
int
hashCode()
Returns the hash code value for this map.

Boolean isEmpty()
Returns true if this map contains no key-value mappings.

Set<K> keySet()
Returns a Set view of the keys contained in this map.
V put(K key, V value)
Associates the specified value with the specified key in this map (optional operation).
V remove(Object key)
Removes the mapping for a key from this map if it is present (optional operation).
int size()
Returns the number of key-value mappings in this map.

POO Java – Cours 4 JP Segado

 ING3 POO Java
 class Map.Entry https://docs.oracle.com/javase/8/docs/api/java/util/Map.Entry.html
 Classe intérieure de Map
 Deux méthodes offertes : 20
K getKey()
Returns the key corresponding to this entry.
V getValue()
Returns the value corresponding to this entry.

 Les méthodes de comparaison utilise equals()

 Les objets clefs doivent redéfinir int Object.hashCode()

Exemple avec l’interface Map :
Map map = new HashMap(); // instancier l’interface Map
String key = "a", value = "alleluai!"; // insérer une clef unique et une valeur quelque soit leur type
map.put(key, value);
Object value = map.get(key); // lire la valeur value de l’objet associée à sa clef
type obj = (type) value ; // faire un cast de l’objet value vers un type (classe) d’objet concret
map.remove(key); // supprimer un objet de la map à partir d’une clef
if (map.containsValue(val)) { … } // si la map contient une valeur, faire quelque chose
if (map.containsKey(key)) { … } // si la map contient une clef, faire quelque chose

Set keys = map.keySet();

Iterator i = keys.iterator(); // Faire une iteration sur les clefs de l’interface map

while (i.hasNext()) { // s’il reste un objet suivant dans l’interface

Object key = (Key) i.next(); // passer à la clef suivante de l’interface
Object value = map.get(key); // lire la valeur value de l’objet associée à sa clef
obj = (type) value ; // faire un cast de l’objet value vers un type (classe) d’objet concret
}

POO Java – Cours 4 JP Segado

 ING3 POO Java

2.5. L’implémentation de Map

21
 HashMap https://docs.oracle.com/javase/8/docs/api/java/util/HashMap.html
 Implémentation de Map par un hash table
 Non-ordonné – Non-synchronisé

 TreeMap https://docs.oracle.com/javase/8/docs/api/java/util/TreeMap.html
 Implémentation de Map par un arbre binaire équilibré
 Ordonné – Non-synchronisé

 Hashtable https://docs.oracle.com/javase/8/docs/api/java/util/Hashtable.html

 Refonte de la classe Hashtable de Java 1.1

 Offre les méthodes du framework et les méthodes historiques
 Avantage d'être synchronisé

POO Java – Cours 4 JP Segado

 ING3 POO Java

2.6. L’implémentation de List

22

 ArrayList https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html
 Implémentation de List par un tableau
 Peut être très rapide, mais est ralentie par des insertions au milieu, ou une changement fréquente de ses dimensions.
 Non-synchronisé
Exemples avec la classe ArrayList

 LinkedList https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html
 Implémentation par une liste dynamique doublement chaînée
 Offre en moyenne une meilleure performance qu'un ArrayList
 Utile pour créer des fils d'attentes avec deux ancres de tête et de queue
 Non-synchronisé

POO Java – Cours 4 JP Segado

 ING3 POO Java
2.7. Trier sa collection

On peut facilement trier une List, mais pour trier un Map ou un Set, il faut utiliser la bonne implémentation.
23

 Pour trier une List

 Utiliser la méthode utilitaire Collections.sort(List)

 Collections.sort(List l, Comparator c)

 Pour avoir un Map trié

 Utiliser l'interface SortedMap

 Et l'implémentation TreeMap

 Pour avoir un Set trié

 Utiliser l'interface SortedSet

 Et l'implémentation TreeSet
Les collections implémentent les algorithmes de tri, mais vous devez fournir la méthode de comparaison utilisée pour trier.

interface Comparable { int compareTo(Object o) ; } // impose une ordre "naturel" sur les objets d'une même classe
interface Comparator { int compare(Object o1, Object o2) ; } // Permet de comparer deux objets de classes différentes

Exemples : cours Interfaces comparable et comparator

Sources des exemples du cours Interfaces Comparable et Comparator
Ces méthodes de comparaison doivent retourner un entier négatif, zéro ou positif quand le premier objet (ou this) est moins grand
que, égal à, ou plus grand que l'autre.

POO Java – Cours 4 JP Segado