+ quiz apprendre la programmation orientée objet avec le

ISBN

: 97

8-2-

409-

0263

0-0

29,9

0 €

Cette troisième édition du livre s’adresse aux étudiants et aux déve-loppeurs ayant déjà une première expérience de la programmation structurée et qui sont désireux de passer à la Programmation Orien-tée Objet (POO) avec le langage Java, pour développer des applica-tions portables.

Après un historique de la POO et du langage Java l’auteur explique pourquoi ce type de programmation est devenu incontournable pour développer dans les environnements graphiques événementiels. Les notions d’objet, de classe et de référence sont présentées puis les fondements de la POO que sont l’encapsulation, l’héritage, le poly-morphisme et l’abstraction. Les différentes étapes d’un développe-ment objet avec les principes de modélisation UML sont exposées.

L’auteur présente ensuite la machine virtuelle Java, son intérêt, sa richesse et un environnement de développement avec IntelliJ IDEA de la société JetBrains. Le lecteur découvre comment Java reproduit les principes de la POO en suivant des explications simples, des exemples concrets et en réalisant des exercices d’entraînement. Il découvre également les types de base du développement Java et leur utilisation, comment exploiter un IDE pour simplifier la saisie des programmes et les mettre au point. Les programmes d’essais sont de type console ou graphique, basés sur l’utilisation de Swing pour illustrer les communications entre objets. Quand ils sont perti-nents, des parallèles sont menés avec les langages de programma-tion objet C++ et C#. La programmation multithread permettant l’exécution simultanée de plusieurs flux d’instructions est présentée, suivie d’une introduction aux tests unitaires tellement importants pour fiabiliser les objets. Une partie consacrée à la réflexion en Java promet quelques surprises. Enfin, le dernier chapitre est consacré aux classes anonymes et aux expressions lambda.

À la fin de ce livre, le lecteur disposera de bases solides pour appré-hender les puissantes API Java et réaliser des programmes objet modulaires, fiables et extensibles.

Des éléments complémentaires sont en téléchargement sur le site www.editions-eni.fr.

Apprendre la Programmation Orientée Objet avec le langage Java

Téléchargementwww.editions-eni.fr.fr

sur www.editions-eni.fr : b Le code source des exemples.b Les corrigés des exercices

proposés dans le livre.

Pour plus d’informations :

Appr

endr

e la

Pro

gram

mat

ion

Orien

tée

Obj

et a

vec

Java

Luc GERVAIS exerce depuis 30 ans la profession de développeur logiciel. Venant du monde de l’électronique, il a commencé par programmer en lan-gage assembleur pour ensuite passer au C, C++, C# et Java. Il a animé de nombreuses formations sur différents langages de programmation aussi bien pour un public de développeurs professionnels que d’étudiants (Uni-versité de Rouen). Cette double expé-rience (technique et pédagogique) lui permet de répondre parfaitement aux attentes des lecteurs désireux de pas-ser à la Programmation Orientée Objet (POO) avec le langage Java.

Apprendre la Programmation

Orientée Objet avec le langage Java

(avec exercices pratiques et corrigés)

Luc GERVAIS

3e édition En téléchargement

corrigés des exercices

code source des exemples

+ QUIZ

1Table des matières

Avant-propos

Chapitre 1Introduction à la POO

1. Histoire de la POO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2. Historique du langage Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

Chapitre 2La conception orientée objet

1. Approche procédurale et décomposition fonctionnelle . . . . . . . . . . . 15

2. La transition vers l'approche objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3. Les caractéristiques de la POO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.1 L'objet, la classe et la référence . . . . . . . . . . . . . . . . . . . . . . . . . . 17

3.1.1 L'objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173.1.2 La classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.1.3 La référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 L'encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.3 L'héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.4 Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.5 L'abstraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4. Le développement objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.1 Cahier des charges du logiciel . . . . . . . . . . . . . . . . . . . . . . . . . . . 254.2 Présentation du cycle en V. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence ENI de l'ouvrage RI3JAPOO dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

lcroise

Tampon

2avec le langage Java

Apprendre la POO

4.3 Rester AGILE avec le corps en V . . . . . . . . . . . . . . . . . . . . . . . . . 304.4 Modélisation et représentation UML . . . . . . . . . . . . . . . . . . . . . 31

4.4.1 Les diagrammes de cas d'utilisation . . . . . . . . . . . . . . . . . 334.4.2 Les diagrammes de classes. . . . . . . . . . . . . . . . . . . . . . . . . 344.4.3 Les énumérations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 414.4.4 Les diagrammes de séquences . . . . . . . . . . . . . . . . . . . . . . 42

4.5 Codage, intégration et mise en production. . . . . . . . . . . . . . . . . 44

5. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.1 Hiérarchie de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455.2 Relations entre objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475.3 Agrégation d’objets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475.4 Diagramme de cas d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . 495.5 Diagramme de séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Chapitre 3Introduction à la plate-forme Java

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

2. Environnement d'exécution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

3. Une librairie très complète. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

4. Des outils de développement performants . . . . . . . . . . . . . . . . . . . . . 57

5. Téléchargement et installation d’IntelliJ IDEA . . . . . . . . . . . . . . . . . 58

6. L'incontournable Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

7. Un point sur les acronymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Chapitre 4Les types en Java

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

2. Les types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

3. Les types référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86


4. Pour nous aider... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88

5. La superclasse java.lang.Object . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 925.1 equals. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 925.2 hashCode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 965.3 toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 975.4 finalize. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 995.5 getClass, .class et l'opérateur instanceof . . . . . . . . . . . . . . . . . . 1005.6 clone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025.7 notify, notifyAll et wait. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

6. La classe java.lang.String . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

7. Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1107.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1107.2 Corrigé. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Chapitre 5Création de classes

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

2. Package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

3. Déclaration d'une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1223.1 Accessibilité des membres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243.2 Attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1253.3 Accesseurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1283.4 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

3.4.1 Étapes de la construction d'un objet . . . . . . . . . . . . . . . 1343.4.2 Surcharge de constructeurs . . . . . . . . . . . . . . . . . . . . . . . 1363.4.3 Chaînage de constructeurs . . . . . . . . . . . . . . . . . . . . . . . 1363.4.4 L'initialiseur static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1393.4.5 L'initialiseur dynamique . . . . . . . . . . . . . . . . . . . . . . . . . 1403.4.6 Les constructeurs de type private . . . . . . . . . . . . . . . . . . 1423.4.7 Le "builder pattern" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

3.5 Destructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147


Apprendre la POO

3.6 Le mot-clé this . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1523.7 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155

3.7.1 Déclaration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1553.7.2 Passages de paramètres par valeur . . . . . . . . . . . . . . . . . 159

3.8 Surcharge des méthodes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1643.9 Mécanisme des exceptions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

3.9.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1663.9.2 Principe de fonctionnement des exceptions . . . . . . . . . 1683.9.3 Prise en charge de plusieurs exceptions . . . . . . . . . . . . . 177

3.10 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1783.10.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1783.10.2 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1793.10.3 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180

4. Les interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1834.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1834.2 Le contrat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1834.3 Déclaration d'une interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1844.4 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1864.5 IntelliJ IDEA et les interfaces. . . . . . . . . . . . . . . . . . . . . . . . . . . 1884.6 Représentation UML d'une interface . . . . . . . . . . . . . . . . . . . . 1904.7 Interfaces et polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . 1904.8 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

4.8.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1914.8.2 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1924.8.3 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195

4.9 Les interfaces de la machine virtuelle Java . . . . . . . . . . . . . . . . 199

5. Associations, compositions et agrégations . . . . . . . . . . . . . . . . . . . . 2025.1 Les tableaux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2105.2 Les collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217

5.2.1 ArrayList<E> et LinkedList<E> . . . . . . . . . . . . . . . . . 2215.2.2 Queue<T> et Stack<T> . . . . . . . . . . . . . . . . . . . . . . . 2255.2.3 HashMap<K, V> . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2255.2.4 Les itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226


5.3 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2275.3.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2275.3.2 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

6. Les classes imbriquées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

7. Quelques différences avec le C# . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Chapitre 6Héritage et polymorphisme

1. Comprendre l'héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

2. Codage de la superclasse (classe de base) et de sa sous-classe (classe héritière) . . . . . . . . . . . . . . . . . . . . . . . . . 2382.1 Interdire l'héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2382.2 Définir les membres héritables . . . . . . . . . . . . . . . . . . . . . . . . . 2392.3 Syntaxe de l'héritage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2392.4 Exploitation d'une classe héritée . . . . . . . . . . . . . . . . . . . . . . . . 240

3. Communication entre classe de base et classe héritière. . . . . . . . . . 2423.1 Les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2423.2 Accès aux membres de la classe de base depuis l'héritier . . . . . 2463.3 Méthodes virtuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2483.4 Méthodes de type "final" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253


5. Les classes abstraites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262

6. Le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2636.1 Comprendre le polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . 2636.2 Exploitation du polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . 2646.3 Les opérateurs instanceof et () . . . . . . . . . . . . . . . . . . . . . . . . . . 265


Apprendre la POO

Chapitre 7Communication entre objets

1. L'événementiel : être à l'écoute . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

2. Le pattern Observateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2682.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2682.2 Implémentation en langage Java . . . . . . . . . . . . . . . . . . . . . . . . 2692.3 Les listeners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2752.4 Utilisation d'un listener dans une application graphique . . . . 276

3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2833.1 Exercice 1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

3.1.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2833.1.2 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284

3.2 Exercice 2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2873.2.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2873.2.2 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287

4. Appels synchrones, appels asynchrones . . . . . . . . . . . . . . . . . . . . . . 290

Chapitre 8Le multithreading

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293

2. Comprendre le multithreading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293

3. Multithreading et Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

4. Implémentation des threads en Java . . . . . . . . . . . . . . . . . . . . . . . . . 2974.1 Étendre la classe Thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2974.2 Implémenter l'interface Runnable . . . . . . . . . . . . . . . . . . . . . . . 3004.3 S'endormir et S'attendre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3024.4 Abandon depuis le thread primaire . . . . . . . . . . . . . . . . . . . . . . 3064.5 Threads et classes anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

4.5.1 Avec l'interface Runnable . . . . . . . . . . . . . . . . . . . . . . . . 3094.5.2 Avec la classe Thread. . . . . . . . . . . . . . . . . . . . . . . . . . . . 310


4.5.3 Accès aux variables et aux données membres simplifié . . . . . . . . . . . . . . . . . 311

5. Synchronisation entre threads. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3155.1 Nécessité de la synchronisation. . . . . . . . . . . . . . . . . . . . . . . . . 3155.2 Les méthodes "synchronized". . . . . . . . . . . . . . . . . . . . . . . . . . . 3175.3 Les traitements "synchronized" . . . . . . . . . . . . . . . . . . . . . . . . . 3195.4 La classe Semaphore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321

6. Communication interthreads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3256.1 La méthode join . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3256.2 Les objets de synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . 327


Chapitre 9Les tests

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

2. Environnement d’exécution des tests unitaires . . . . . . . . . . . . . . . . 347

3. Le projet avec tests unitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

4. La classe de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

5. Contenu d’une méthode de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

6. Traitements de préparation et de nettoyage . . . . . . . . . . . . . . . . . . 356

7. Les tests avec paramètres externes . . . . . . . . . . . . . . . . . . . . . . . . . . 359

8. Les suites de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364



Apprendre la POO

Chapitre 10La réflexion

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

2. Mais pour quoi faire ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367

3. Introspection d'une classe Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369

4. Chargement dynamique et utilisation d'une classe découverte . . . 372

5. Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

6. Privé, mais pas tant…. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380

7. Décompilation et obfuscation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381

Chapitre 11Anonymat et lambda

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395

2. Les classes anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3962.1 D’une pierre deux coups. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3962.2 Syntaxe particulière . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3962.3 Exemple d'extension d'une superclasse . . . . . . . . . . . . . . . . . . . 3972.4 Exemple d'implémentation d'une interface . . . . . . . . . . . . . . . 3992.5 Échange d’informations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4012.6 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

2.6.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4032.6.2 Corrigé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403

3. Les expressions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4053.1 Le concept . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4053.2 Les interfaces « fonctionnelles » comme modèles . . . . . . . . . . . 4063.3 Les syntaxes lambda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4083.4 Échange d’informations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409


3.5 Exercice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4093.5.1 Énoncé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4093.5.2 Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409

3.6 Paramètre type Lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4123.7 java.util.function, un package « vivier » . . . . . . . . . . . . . . . . . . 4143.8 Application sur des collections . . . . . . . . . . . . . . . . . . . . . . . . . 4153.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417


Apprendre la POO

15

Chapitre 2La conception orientée objet

La conception orientée objet1. Approche procédurale et décomposition fonctionnelleAvant d'énoncer les bases de la programmation orientée objet, nous allonsrevoir l'approche procédurale à l'aide d'un exemple concret d'organisation decode.

Dans cet ouvrage reviennent souvent les termes "code", "coder", "codage" ; il nes’agit ni d’alarmes ni de fonctions de cryptage de mot de passe. Le code ou codesource est en fait le nom donné au contenu que le développeur entre à lon-gueur de journée dans son éditeur de texte favori pour être ensuite converti(ou encore compilé) en flux d’instructions exécutables par l’ordinateur.

La programmation procédurale est un paradigme de programmation considé-rant les différents acteurs d'un système comme des objets pratiquementpassifs qu'une procédure centrale utilisera pour une fonction donnée.

lcroise

Tampon

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Apprendre la POO

Prenons l'exemple de la distribution d'eau courante dans nos habitations etessayons d'en modéliser le principe dans une application très simple. L'analyseprocédurale (tout comme l'analyse objet d'ailleurs) met en évidence une listed'objets qui sont :

– le robinet de l'évier ;

– le réservoir du château d'eau ;

– un capteur de niveau d'eau avec contacteur dans le réservoir du châteaud’eau ;

– la pompe d'alimentation puisant l'eau dans la rivière.

Le code du programme "procédural" consisterait à créer un ensemble devariables représentant les paramètres de chaque composant puis à écrire uneboucle de traitement de gestion centrale testant les valeurs lues et agissant enfonction du résultat des tests. On notera qu'il y a d'un côté les variables, del'autre, les actions et au-dessus le gestionnaire tout puissant par qui touttransite.

2. La transition vers l'approche objetLa programmation orientée objet est un paradigme de programmation consi-dérant les différents acteurs d'un système comme des objets actifs et en rela-tion. L'approche objet est souvent très voisine de la réalité.

Dans notre exemple :

– L'utilisateur ouvre le robinet.

– Le robinet relâche la pression et l'eau s'écoule du réservoir du château d’eauà l'évier.

– Comme notre utilisateur n’est pas tout seul à consommer, le capteur/flotteur du réservoir arrive à un niveau qui déclenche la pompe de puisagedans la rivière.

– L'utilisateur referme le robinet.

– Alimenté par la pompe, le réservoir du château d'eau continue à se remplirjusqu’à ce que le capteur/flotteur atteigne le niveau suffisant qui arrêtera lapompe.

17La conception orientée objetChapitre 2

– Arrêt de la pompe.

Dans cette approche, vous constatez que les objets "interagissent" ; il n'existepas de traitement central définissant dynamiquement le fonctionnement desobjets. Il y a eu, en amont, une analyse fonctionnelle qui a conduit à lacréation des différents objets, à leur réalisation et à leur mise en relation.

Le code du programme "objet" va suivre cette réalité en proposant autantd'objets que décrit précédemment mais en définissant entre ces objets desméthodes d'échange adéquates qui conduiront au fonctionnement escompté.

RemarqueLes concepts objets sont très proches de la réalité...

3. Les caractéristiques de la POO

3.1 L'objet, la classe et la référence

3.1.1 L'objet

L'objet est l'élément de base de la POO. L'objet est la réunion :

– d'une liste de variables d'états ;

– d'une liste de comportements ;

– d'une identification.

Les variables d'états changent durant la vie de l'objet. Prenons le cas d'unlecteur de musiques numériques. À l'achat de l'appareil, les états de cet objetpourraient être :

– mémoire libre = 100% ;

– taux de charge de la batterie = correct ;

– aspect extérieur = neuf.

Au fur et à mesure de son utilisation, ses états vont être modifiés. Rapidementla mémoire libre va chuter, le taux de charge de la batterie variera et l'aspectextérieur va changer en fonction du soin apporté par l'utilisateur.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Apprendre la POO

Les comportements de l'objet définissent ce que peut faire cet objet :

– Jouer de la musique

– Aller à la piste suivante

– Aller à la piste précédente

– Monter le son

– etc.

Une partie des comportements de l'objet est accessible depuis l'extérieur de cetobjet : Bouton Play, Bouton Stop... et une autre partie est uniquementinterne : lecture de la carte mémoire, décodage de la musique à partir dufichier. On parle "d'encapsulation" pour définir la limite entre les comporte-ments accessibles de l'extérieur et les comportements internes.

L'identification d'un objet est une information, détachée de la liste des états,permettant de différencier cet objet particulier de ses congénères (c’est-à-dired'autres objets qui ont le même type que lui). L'identification peut être unnuméro de référence ou une chaîne de caractères unique construite à lacréation de l'objet ; elle peut également être l'adresse mémoire où l’objet eststocké. En réalité, sa forme dépend totalement de la problématique associée.

L'objet programmé peut être attaché à une entité bien réelle, comme pournotre lecteur numérique, mais il peut être également attaché à une entité tota-lement virtuelle comme un compte client, l'entrée d'un répertoire télépho-nique... La finalité de l'objet informatique est de gérer l'entité physique ou del'émuler.

Même si ce n'est pas dans sa nature de base, l'objet peut être rendu persistant,c'est-à-dire que ses états peuvent être enregistrés sur un support physiquemémorisant l'information de façon intemporelle. À partir de cet enregistre-ment, l'objet pourra être reconstruit avec ses états quand le système le souhai-tera. Le support typique capable d’une telle prouesse est la base de données.


3.1.2 La classe

La classe est le "moule" à partir duquel l'objet va être créé en mémoire. La classedécrit les états et les comportements communs d'un même type. Les valeursde ces états seront contenues dans les objets issus de la classe.

Les comptes courants d'une même banque contiennent tous les mêmesparamètres (coordonnées du détenteur, solde, etc.) et ils ont tous les mêmesfonctions (créditer, débiter, nous rappeler à l’ordre si besoin, etc.). Cesdéfinitions doivent être contenues dans une classe et, à chaque fois qu'unclient ouvre un nouveau compte, cette classe servira de modèle à la créationdu nouvel objet compte.

Le présentoir de lecteurs de musiques numériques propose un même modèleen différentes couleurs, avec des tailles mémoires différentes et modulables,etc. Chaque appareil du présentoir est un objet qui a été fabriqué à partir desinformations d'une seule classe. À la réalisation, les attributs de l'appareil ontété choisis en fonction de critères esthétiques et commerciaux décidés par deschefs produits très au fait des tendances d’achats des clients.

Une classe peut contenir beaucoup d'attributs. Ils peuvent être de type primi-tif – des entiers, des caractères... – mais également de type plus complexe. Eneffet, une classe peut contenir une ou plusieurs classes d'autres types. On parlealors de composition ou encore de "couplage fort". Dans ce cas la destructionde la classe principale entraîne, évidemment, la destruction des classes qu'ellecontient. Par exemple, si une classe hôtel contient une liste de chambres, ladestruction de l'hôtel entraîne la destruction de ses chambres.

Une classe peut faire "référence" à une autre classe ; dans ce cas, le couplage estdit "faible" et les objets peuvent vivre indépendamment. Par exemple, votrePC est relié à votre imprimante. Si votre PC rend l'âme, votre imprimantefonctionnera certainement avec votre futur PC ! On parle alors d'association.

En plus de ses attributs, la classe contient également une série de "comporte-ments", c'est-à-dire une série de méthodes avec leurs signatures et leurs implé-mentations attachées. Ces méthodes appartiennent aux objets et sontutilisées telles quelles.

© E

diti

ons

ENI -

All

righ

ts r

eser

ved


Apprendre la POO

On déclare la classe et son contenu dans un même fichier source à l'aide d'unesyntaxe que l'on étudiera en détail. Les développeurs C++ apprécieront le faitqu'il n'existe plus, d'un côté, une partie définitions du contenu de la classe et,de l'autre, une partie implémentations. En effet, en Java (tout comme en C#),le fichier programme (d'extension .java) contient les définitions de tous lesétats avec éventuellement une valeur "de départ" et les définitions et implé-mentations de tous les comportements. Contrairement au C#, une classe Javade haut niveau – nous reviendrons sur cette notion plus loin – doit être définiedans un seul fichier source.

3.1.3 La référence

Les objets sont construits à partir de la classe, par un processus appelé l'instan-ciation, et donc, tout objet est une instance d'une classe. Chaque instancecommence à un emplacement mémoire unique. L’adresse de cet emplacementmémoire connue sous le nom de pointeur par les développeurs C et C++devient une référence pour les développeurs Java et C#.

Quand le développeur a besoin d'un objet pendant un traitement, il doit fairedeux actions :

– déclarer et nommer une variable du type de la classe à utiliser ;

– instancier l'objet et enregistrer sa référence dans cette variable.

Une fois cette instanciation réalisée, le programme accédera aux propriétés etaux méthodes de l'objet par la variable contenant sa référence. Chaqueinstance est unique. Par contre, plusieurs variables peuvent "pointer" sur unemême instance. C'est d'ailleurs quand plus aucune variable ne pointe sur uneinstance donnée que le ramasse-miettes enregistre cette instance commedevant être détruite.


3.2 L'encapsulation

L'encapsulation consiste à créer une sorte de boîte noire contenant en interneun mécanisme protégé et en externe un ensemble de commandes qui vont per-mettre de la manipuler. Ce jeu de commandes est fait de telle sorte qu'il seraimpossible d'altérer le mécanisme protégé en cas de mauvaise utilisation. Laboîte noire sera si opaque qu'il sera impossible à l'utilisateur d'intervenir endirect sur le mécanisme.

Vous l'aurez compris, la boîte noire n'est autre qu'un objet avec des méthodespubliques de "haut niveau" contrôlant avec rigueur les paramètres passésavant de les utiliser dans un traitement. En respectant le principe del'encapsulation, vous ferez en sorte que jamais l'utilisateur de l'objet ne puisseaccéder "en direct" à vos données. Grâce à ce contrôle, votre objet seracorrectement utilisé, donc plus fiable, et sa mise au point sera plus facile. Dansle monde Java, les méthodes permettant d'accéder en lecture aux données sontdes accesseurs et celles permettant d’accéder en écriture sont des mutateurs.

Java ne propose pas d’équivalence aux propriétés (properties) du langage C#qui permettent de garder le côté pratique de l’accès direct aux données del’objet tout en respectant les principes de l’encapsulation.

3.3 L'héritage

Une autre caractéristique importante de la POO consiste à pouvoir créer uneclasse en partant d’une autre. Cela s’appelle l'héritage. Pour l'expliquer, imagi-nons que nous devions construire un système de gestion des différents typesde collaborateurs d'une société. Une analyse rapide met en évidence une listede propriétés communes à tous les postes. En effet, que le collaborateur soitouvrier, cadre, intérimaire ou encore directeur, il a toujours un nom, unprénom et un numéro de sécurité sociale... On appelle cela la généralisation ;elle consiste à factoriser les éléments communs d’un ensemble de classes dansune classe plus générale appelée superclasse en Java et plutôt "classe de base"en C# et C++. La classe qui hérite de la superclasse est appelée sous-classe,classe héritière ou encore classe spécialisée.

+ quiz apprendre la programmation orientée objet avec le

Documents