Programmation Orientée Objet

Lancelot Pecquet
Programmation Orient´ee Objet
Introduction illustr´ee en Java
Universit´e de Poitiers, Licence d’Informatique
Version 1.1, du 19 janvier 2006

Qu’attendre de ce document ?
Ce document a pour objectif principal de faire d´ecouvrir, `a un public d´ebutant en la mati`ere,
les fondements de la programmation orient´ee objet. Le c´el`ebre langage Java est utilis´e pour illustrer
les concepts th´eoriques. Ces quelques pages ne constituent aucunement un manuel de r´ef´erence du
langage Java et il conviendra de se reporter pour cela au manuel en ligne, disponible, par exemple,
sur http://java.sun.com/docs/. Des lectures compl´ementaires pour approfondir les sujets abord´es
dans cette introduction sont sugg´er´ees dans la conclusion, p. 75.
La version originale de ce document est librement consultable en version ´electronique (.ps.gz) sur
http://lancelot.pecquet.org. Celle-ci peut ´egalement ˆetre librement copi´ee et imprim´ee. Tout
commentaire constructif (de l’erreur typographique `a la grosse bourde) est le bienvenu et peut ˆetre
envoy´e `a [email protected].

Table des mati`eres
1 Introduction `a la Programmation Orient´ee Objet 11
1.1 Qu’est-ce que la Programmation Orient´ee Objet (POO) ? . . . . . . . . . . . . . . . . 11
1.2 Int´erˆet de la POO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Vue informelle des concepts fondamentaux de la POO . . . . . . . . . . . . . . . . . . 11
1.3.1 Classes et m´ethodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3.2 Encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3.3 H´eritage et polymorphisme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Fonctionnement g´en´eral de Java 13
2.1 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.2 Avantages et inconv´enients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 Compilation et ex´ecution des programmes Java . . . . . . . . . . . . . . . . . . . . . . 14
2.3.1 Machine Virtuelle Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.2 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3.3 Assembleur Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4 Hello World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5 Environnement de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.6 Documentation en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3´ El´ements simples de Java 21
3.1 Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2 Types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.3 Op´erateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4 Affichage polymorphe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.5 Port´ee des identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.6 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.6.2 if ........................................... 24
3.6.3 switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.6.4 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.7 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.7.1 for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.7.2 while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.7.3 do. . . while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.7.4 Distinction fondamentale entre for et while . . . . . . . . . . . . . . . . . . . 26
3.7.5 Sortie de boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
3.8 Tableaux primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.1 Tableaux unidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3.8.2 Tableaux multidimensionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3

4TABLE DES MATI ` ERES
4 Fondements objet de Java 29
4.1 Structure des classes en Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1.1 Syntaxe d’une classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1.2 Modes d’encapsulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1.3 D´er´ef´erencement des attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.4 Attributs final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.5 Attributs static . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.6 Constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.1.7 Notes sur les constructeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Constructeurs, accesseurs et mutateurs final . . . . . . . . . . . . . . . . . . . 32
Utilisation de this() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.1.8 Le destructeur finalize() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.1.9 Conversion des objets en chaˆıne de caract`eres . . . . . . . . . . . . . . . . . . . 33
4.2 Classes enveloppantes des types primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.3 Classes internes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5 H´eritage, classes abstraites et interfaces 35
5.1 H´eritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.1.2 Les classes Object et Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.2 M´ethodes et classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.3 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.2 H´eritage multiple des interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.3 Impl´ementation d’une interface . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3.4 Interfaces indicatrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6 Interruptions 41
6.1 La classe Throwable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.2 Syntaxe des gestionnaires d’interruptions . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.3 La classe Exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6.4 La classe Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.5 Interruptions v´erifi´ees et non-v´erifi´ees, RuntimeException . . . . . . . . . . . . . . . . 44
7 Paquetages et documentation 47
7.1 Paquetages (package) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
7.2 Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
7.2.1 G´en´eration automatique de documentation . . . . . . . . . . . . . . . . . . . . 48
7.2.2 D´efinition de quelques balises . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
8´ Egalit´e, comparabilit´e, clonage 51
8.1 Transtypage (cast) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.2 L’op´erateur instanceof . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.1.3 Upcast implicite des types primitifs . . . . . . . . . . . . . . . . . . . . . . . . 52
8.1.4 Downcast explicite des types primitifs . . . . . . . . . . . . . . . . . . . . . . . 53
8.1.5 Upcast implicite des types non-primitifs . . . . . . . . . . . . . . . . . . . . . . 53
8.1.6 Downcast explicite des types non-primitifs . . . . . . . . . . . . . . . . . . . . . 53
8.1.7 Tableaux de types non-primitifs . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.2 ´ Egalit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
8.3 Comparabilit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.4 Copie et clonage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

TABLE DES MATI ` ERES 5
9 Conteneurs et it´erateurs 59
9.1 L’interface Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
9.2 L’interface Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.3 Repr´esentation des ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.3.1 L’interface Set et sa d´eriv´ee SortedSet . . . . . . . . . . . . . . . . . . . . . . 60
9.3.2 L’impl´ementation HashSet de Set . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.3.3 L’impl´ementation TreeSet de SortedSet . . . . . . . . . . . . . . . . . . . . . 61
9.4 Repr´esentation des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.4.1 L’interface List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.4.2 L’impl´ementation ArrayList de List . . . . . . . . . . . . . . . . . . . . . . . 61
9.4.3 L’impl´ementation LinkedList de List . . . . . . . . . . . . . . . . . . . . . . . 61
9.5 Repr´esentation des applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.5.1 L’interface Map et sa d´eriv´ee SortedMap . . . . . . . . . . . . . . . . . . . . . . 61
9.5.2 Les impl´ementations HashMap (et WeakHashMap) de Map . . . . . . . . . . . . . 62
9.5.3 Les impl´ementations TreeMap de SortedMap . . . . . . . . . . . . . . . . . . . . 62
10 ´ Etude d´etaill´ee de la classe String 63
10.1 String,char[],StringBuffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
10.2 Fonctions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
10.3 Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
10.4 Tests d’´egalit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
10.5 Recherche de motifs (pattern matching) . . . . . . . . . . . . . . . . . . . . . . . . . . 64
10.6 Manipulation de chaˆınes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
10.7 Analyseur lexical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
10.8 R´ecup´eration d’une page web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
11 Threads et interface Runnable 65
11.1 Processus l´egers = fils = threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
11.2 Exemple : le dˆıner des philosophes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12 Application Programming Interface (API) Java 69
12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
12.2 Entr´ees/sorties java.io . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
12.2.1 Entr´ee et sortie standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
12.2.2 La classe File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
12.2.3 Lecture d’un fichier texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
12.2.4 ´ Ecriture dans un fichier texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
12.2.5 Lecture/´ecriture dans un fichier `a acc`es al´eatoire . . . . . . . . . . . . . . . . . 70
12.3 Math´ematiques java.math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
12.4 Paquetages utilitaires java.util . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
12.4.1 Nombres al´eatoires java.util.Random . . . . . . . . . . . . . . . . . . . . . . . 70
12.4.2 Analyse lexicale java.util.StringTokenizer . . . . . . . . . . . . . . . . . . 71
12.5 Applets java.applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
13 Conclusion et lectures sugg´er´ees 75