Introduction à la programmation orientée objet et au langage Java Arnaud PÊCHER

Arnaud PÊCHER
Université de Bordeaux (LaBRI)
http://www.labri.fr/pecher/pmwiki/pmwiki.php/Teaching/2013AS
Introduction à la programmation orientée objet
et au langage Java
DUT Informatique - Année Spéciale
2013-2014

Table des matières
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" ............................. 13
1.4 Conclusion : quand utiliser Processing ? Java ? ............................ 14
I Introduction à la programmation orientée objet 17
2 Bases de la programmation objet 19
2.1 Le modèle objet ............................................ 19
2.1.1 Classes, types, attributs, méthodes .............................. 19
2.1.2 Déroulement d’un programme objet et mot-clef this ................... 22
2.1.3 Cycle de vie d’un objet .................................... 23
2.1.4 Surcharge de méthodes .................................... 25
2.2 Conversions entre types de bases et leurs classes dédiées ...................... 26
2.3 Tableaux, collections d’objets ..................................... 27
3 Instances & Encapsulation 31
3.1 De Processing à Java ......................................... 31
3.1.1 Premiers pas en Java ..................................... 31
3.1.2 Réutiliser les bibliothèques de Processing ........................ 32
3.2 Instances d’objets ........................................... 34
3.2.1 Attributs et méthodes statiques ................................ 34
3.2.2 Passage d’objets en paramètres d’une méthode ....................... 35
3.2.3 Copie d’une instance ..................................... 37
3.3 Encapsulation ............................................. 38
3.3.1 Paquets ............................................ 39
3.3.2 Visibilté ............................................ 39
3.3.3 Accesseurs .......................................... 40
4 Héritage, classes abstraites, interfaces 43
3

4TABLE DES MATIÈRES
4.1 Héritage ................................................ 45
4.1.1 Redéfinition d’une méthode ou d’un attribut ......................... 46
4.1.2 Les méthodes disponibles pour toutes les classes ...................... 48
4.2 Classes, méthodes abstraites et interfaces .............................. 48
4.2.1 Classes et méthodes abstraites ................................ 49
4.2.2 Interfaces ........................................... 49
4.3 Exemple : modélisation générique d’un labyrinthe .......................... 50
5 Polymorphisme & compléments sur les collections 55
5.1 Polymorphisme ............................................ 56
5.2 Collections .............................................. 59
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 Découverte des principales commandes du JDK et des bibliothèques de Java 67
6.1 Premiers pas en Java avec le JDK ................................... 67
6.2 Outils de développement ....................................... 68
6.2.1 Compilation : javac (Java Compiler) ............................ 68
6.2.2 Exécution d’un programme : java ............................. 69
6.2.3 Génération automatisée de la documentation : javadoc (Java DOCumentation) ..... 70
6.2.4 Création d’archives : jar (Java aRchive) .......................... 70
6.2.5 Débogage : jdb (Java DeBugger) .............................. 71
6.2.6 javap (Java Disassembler) .................................. 71
6.2.7 javah (Java C Header generators) ............................... 71
6.2.8 Génération de services web : wsgen (côté serveur), wsimport (côté client) ....... 71
6.2.9 Exécution d’une application java distante : javaws (Java WebStart) ............ 71
6.2.10 Génération d’applications réparties : rmic (Java Remothe Method Invocation Compiler) . 71
6.3 Principales bibliothèques ....................................... 71
6.3.1 Interfaces graphiques : java.awt et javax.swing ................... 72
6.3.2 java.lang ......................................... 72
6.3.3 Entrées-Sortie : java.io .................................. 72
6.3.4 Réseaux : java.net .................................... 73
6.3.5 java.util ............................................ 73
7 Contrôle des erreurs : débogage, tests unitaires et exceptions 75
7.1 Débogage ............................................... 76
7.1.1 En ligne de commande : jdb ................................ 76
7.1.2 Dans Eclipse ......................................... 79
7.2 Tests unitaires ............................................. 79
7.3 Exceptions ............................................... 80
8 Entrées-sorties : Flux, Fichiers, Sérialisation, XML 87
8.1 Flux en entrée/sortie ......................................... 87
8.1.1 Traitement des erreurs d’entrée/sortie ............................ 88
8.1.2 Les flux d’octets ....................................... 88

TABLE DES MATIÈRES 5
8.1.3 Les flux de caractères ..................................... 89
8.1.4 Flux avec tampons ...................................... 90
8.2 Fichiers, réseau et sérialisation (objets persistants) .......................... 91
8.2.1 Fichiers ............................................ 91
8.2.2 Réseau ............................................ 95
8.2.3 Sérialisation ......................................... 98
8.2.4 RMI : Remote Method Interface ............................... 99
8.3 XML : eXtensible Mark-up Language ................................100
8.3.1 Présentation ..........................................100
8.3.2 Java et XML .........................................102
III Java (un peu plus) avancé 107
9 Programmation multi-processus légers 109
9.1 Contrôler un processus : de sa création à sa terminaison .......................109
9.1.1 Création ............................................109
9.1.2 Processus bloqués ......................................111
9.1.3 Terminaison d’un processus .................................111
9.1.4 Groupes de processus .....................................111
9.1.5 Démons ............................................112
9.2 Coordination de plusieurs processus : les verrous ..........................112
10 Connexion directe avec des bases de données relationnelles avec JDBC 115
10.1 JDBC : structure de la bibliothèque ..................................115
10.1.1 Se connecter à une base ...................................116
10.1.2 Modifier des données .....................................117
10.1.3 Regrouper des actions ....................................118
10.1.4 Sélectionner des données ...................................118
10.1.5 Types de données et métadonnées ..............................118
10.2 JDBC2 .................................................119
11 Réagir à des évènements : les écouteurs 123
12 Interfaces graphiques en SWING 131
12.1 Composants ..............................................131
12.2 Component vs. Container .......................................132
12.3 Gestionnaire de placement : l’interface LayoutManager .......................132
12.4 Exemple : fenêtre principale .....................................132
12.5 Dessiner : la classe Graphics .....................................133
12.6 Exercice : le jeu de Taquin ......................................134
13 Interfaces graphiques en SWT 137
13.1 Découverte sur un exemple type ...................................137
13.2 Multiprocessus et SWT ........................................138
13.3 Principaux écouteurs de SWT ....................................139
13.4 Composants ..............................................141
13.5 Disposition des composants : Layouts ................................142
13.6 Composants SWT ...........................................144
13.6.1 Liste des principaux composants ...............................144
13.6.2 Utilisation de quelque composants ..............................145
13.7 Boites de dialogue ...........................................149