Introduction ` a la programmation orient´ ee objet et au langage Java

Arnaud PÊCHER
Université de Bordeaux (LaBRI)
http://www.labri.fr/pecher/pmwiki/pmwiki.php/Teaching/2014
Introduction `a la programmation orient´ee objet
et au langage Java
DUT Informatique - Ann´ee Sp´eciale
2014-2015

Table des mati`eres
1 Premiers pas en Java à l’aide de Processing 3
1.1 Présentation de l’environnement et du langage Processing ...................... 3
1.2 Programmation impérative : enchaînement d’instructions ...................... 4
1.2.1 Premiers pas ......................................... 4
1.2.2 Variables et affectations ................................... 5
1.2.3 Structures de contrôle .................................... 6
1.2.4 Méthodes et appels de méthodes ............................... 8
1.2.5 Manipulation de chaines de caractères ............................ 10
1.2.6 Manipulations de fichiers ................................... 11
1.2.7 Tests ............................................. 12
1.3 Présentation du langage Java ..................................... 12
1.3.1 Historique et positionnement ................................. 12
1.3.2 Particularités ......................................... 13
1.3.3 Ecrire un programme en Java "pur" ............................. 14
1.3.4 Affichage : format versus print .............................. 15
1.4 Conclusion : quand utiliser Processing ? Java ? ............................ 16
I Introduction à la programmation orientée objet 19
2 Bases de la programmation objet 21
2.1 De Processing à Java ......................................... 21
2.1.1 Premiers pas en Java ..................................... 21
2.1.2 Réutiliser les bibliothèques de Processing ......................... 22
2.2 Le modèle objet ............................................ 24
2.2.1 Classes, types, attributs, méthodes .............................. 24
2.2.2 Déroulement d’un programme objet et mot-clef this .................... 28
2.2.3 Cycle de vie d’un objet .................................... 29
2.2.4 Surcharge de méthodes .................................... 31
2.3 Conversions entre types de bases et leurs classes dédiées ...................... 32
2.4 Tableaux, collections d’objets ..................................... 33
3 Instances & Encapsulation 35
3.1 Instances d’objets ........................................... 36
3.1.1 Attributs et méthodes statiques ................................ 36
3.1.2 Passage d’objets en paramètres d’une méthode ....................... 38
3.1.3 Copie d’une instance ..................................... 39
3.2 Encapsulation ............................................. 41
3.2.1 Paquets ............................................ 41
3.2.2 Visibilité ........................................... 41
3.2.3 Accesseurs .......................................... 42
3

4TABLE DES MATI` ERES
4 Héritage, classes abstraites, interfaces 45
4.1 Héritage ................................................ 47
4.1.1 Redéfinition d’une méthode ou d’un attribut ......................... 48
4.1.2 Les méthodes disponibles pour toutes les classes ...................... 50
4.2 Classes, méthodes abstraites et interfaces .............................. 50
4.2.1 Classes et méthodes abstraites ................................ 50
4.2.2 Interfaces ........................................... 51
4.3 Exemple : modélisation générique d’un labyrinthe .......................... 52
5 Polymorphisme & compléments sur les collections 55
5.1 Polymorphisme ............................................ 56
5.2 Collections .............................................. 58
5.2.1 L’interface Collection .................................... 59
5.2.2 Les listes doublement chainées ................................ 60
5.2.3 les vecteurs ou tableaux dynamiques ............................. 61
5.2.4 Les tables de hachage et les collections partiellement ordonnées .............. 61
5.2.5 Les ensembles ........................................ 62
5.2.6 Les associations ....................................... 62
5.2.7 Les vues et les opérations de masse ............................. 62
5.2.8 Algorithmes ......................................... 63
II Java Developpment Kit et quelques compléments incontournables 65
6 Contrôle des erreurs : débogage, tests unitaires et exceptions 67
6.1 Débogage ............................................... 68
6.1.1 En ligne de commande : jdb ................................. 68
6.1.2 Dans Eclipse ......................................... 71
6.2 Tests unitaires ............................................. 71
6.3 Exceptions ............................................... 72
7 Entrées-sorties : Flux, Fichiers, Sérialisation, XML 79
7.1 Flux en entrée/sortie ......................................... 79
7.1.1 Traitement des erreurs d’entrée/sortie ............................ 80
7.1.2 Les flux d’octets ....................................... 80
7.1.3 Les flux de caractères ..................................... 81
7.1.4 Flux avec tampons ...................................... 81
7.2 Fichiers, réseau et sérialisation (objets persistants) .......................... 82
7.2.1 Fichiers ............................................ 83
7.2.2 Réseau ............................................ 86
7.2.3 Sérialisation ......................................... 89
7.3 RMI : Remote Method Interface ................................... 90
7.3.1 Côté serveur ......................................... 90
7.3.2 Coté client .......................................... 91
7.4 XML : eXtensible Mark-up Language ................................ 92
7.4.1 Présentation .......................................... 92
7.4.2 Java et XML ......................................... 94
III Java (un peu plus) avancé 99
8 Programmation multi-processus légers 101
8.1 Contrôler un processus : de sa création à sa terminaison .......................101
8.1.1 Création ............................................101

TABLE DES MATI` ERES 5
8.1.2 Processus bloqués ......................................103
8.1.3 Terminaison d’un processus .................................103
8.1.4 Groupes de processus .....................................103
8.1.5 Démons ............................................104
8.2 Coordination de plusieurs processus : les verrous ..........................104
9 Connexion directe avec des bases de données relationnelles avec JDBC 109
9.1 JDBC : structure de la bibliothèque ..................................109
9.1.1 Se connecter à une base ...................................110
9.1.2 Modifier des données .....................................111
9.1.3 Regrouper des actions ....................................111
9.1.4 Sélectionner des données ...................................112
9.1.5 Types de données et métadonnées ..............................112
9.2 JDBC2 .................................................113
10 Réagir à des évènements : les écouteurs 117
10.1 Les écouteurs .............................................117
10.1.1 La bibliothèque awt.event .................................117
10.1.2 Adaptateurs ..........................................119
10.2 Classes internes et anonymes .....................................121
10.2.1 Les classes internes simples .................................123
10.2.2 Les classes internes aux méthodes ..............................124
10.2.3 Les classes internes anonymes ................................125
10.2.4 Les classes internes statiques .................................125
11 Interfaces graphiques en SWING 129
11.1 Introduction à SWING ........................................129
11.2 Gestionnaire de placement : l’interface LayoutManager .......................130
11.3 Dessiner : la classe Graphics .....................................131
12 Interfaces graphiques en SWT 135
12.1 Découverte sur un exemple type ...................................135
12.2 Multiprocessus et SWT ........................................136
12.3 Principaux écouteurs de SWT ....................................137
12.4 Composants ..............................................139
12.5 Disposition des composants : Layouts ................................140
12.6 Composants SWT ...........................................142
12.6.1 Liste des principaux composants ...............................142
12.6.2 Utilisation de quelque composants ..............................143
12.7 Boites de dialogue ...........................................147
13 Annotations et trois applications 151
13.1 Les annotations ............................................152
13.1.1 Les annotations standards ..................................152
13.1.2 Les annotations personnalisées ................................153
13.1.3 Les méta-annotations .....................................153
13.1.4 Comparaison XML/annotations ...............................154
13.2 Application : les objets persistants ..................................154
13.2.1 Les principale annotation de JPA - Java Persistence API ..................154
13.2.2 En pratique via des annotations : des objets persistants Personne .............155
13.3 Application : les servlets .......................................159
13.3.1 Présentation des servlets ...................................159
13.3.2 Annotations pour les servlets .................................161
13.3.3 En pratique : quelques servlets via des annotations .....................161