Cahier de TP Java

DESS IGSI Java
À : DESS IGSI De : Laurent Perrussel (Laurent.Perrussel@univ-tlse1.fr) Date : 02/12/02
Introduction L'objectif de ce mémo est de présenter le langage Java. La programmation
Java s'effectuera à l'aide de l'outil de développement JBuilder. Chaque
chapitre fait l'objet d'une séance de travaux pratiques. Les travaux
pratiques complètent le cours de programmation : les concepts de
programmation (structures de données et de contrôles) sont supposés connus.
Le mémo est organisé en chapitres : chaque chapitre traite d'un thème et
fait l'objet d'une mise en pratique en T.P. Les thèmes ne sont pas
indépendants : ils supposent une certaine continuité dans l'apprentissage. TABLES DES MATIERES Introduction 1
1 TP n° 1 : Concepts de base 6 1.1 Programmation orienté-objet 6
1.2 Identifier et créer un objet 6
1.3 Les données 7
1.3.1 Données primitives 8
1.3.2 Les tableaux 8
1.3.3 Les chaînes de caractères 9
1.3.4 Accès aux données 9
1.4 Les classes 7
1.4.1 Description type d'une classe 7
1.5 JBuilder 3 10
1.6 Exercice 10
1.6.1 A faire 14
1.7 Ce qu'il faut retenir 14
1.8 Vos notes 14 2 TP n° 2 : définir des méthodes 15 2.1 Squelette d'une méthode 15
2.2 Valeur de retour 16
2.3 Appeler la méthode d'un objet 16
2.4 La liste des arguments 16
2.5 Les instructions de traitements 17
2.5.1 Opérateurs mathématiques 17
2.5.2 Instructions de contrôle 17
2.5.2.1 Instruction conditionnelle 18
2.5.2.2 Les instructions d'itérations 18
2.6 Exercice 19
2.6.1 A faire 20
2.7 Ce qu'il faut retenir 20
2.8 Vos notes 20 3 TP n°3 : Affiner la définition des classes - Constructeurs et
visibilités 21 3.1 Constructeurs 21
3.2 Visibilité des classes et de leur contenu 22
3.2.1 Visibilité de la classe 22
3.2.2 Visibilité des données et méthodes 22
3.3 Exercice 23
3.3.1 A faire 24
3.4 Ce qu'il faut retenir 24
3.5 Vos notes 24 4 TP 4 : Création d'un dialogue 25 4.1 La construction d'une interface 25
4.2 Les composants 25
4.2.1 Chargement des bibliothèques 25
4.2.2 Type de composants 25
4.2.2.1 Les conteneurs 25
4.2.2.2 Les contrôles 26
4.3 Description des contrôles 27
4.3.1 Les boutons 27
4.3.1.1 Constructeurs 27
4.3.1.2 Quelques méthodes 27
4.3.2 Les boites à cocher 28
4.3.2.1 Constructeurs 28
4.3.2.2 Quelques méthodes 28
4.3.3 Les listes de choix 28
4.3.3.1 Constructeurs 28
4.3.3.2 Quelques méthodes 29
4.3.4 Les listes 29
4.3.4.1 Constructeurs 29
4.3.4.2 Quelques méthodes 30
4.3.5 Les zones de saisie 30
4.3.5.1 Constructeurs 30
4.3.5.2 Quelques méthodes 31
4.4 Disposer les contrôles 31
4.4.1 FlowLayout 31
4.4.2 BorderLayout 32
4.4.3 GridLayout 32
4.4.4 GridBagLayout 32
4.5 Exercice 32
4.6 A faire 35
4.7 Ce qu'il faut retenir 35
4.8 Vos notes 35 5 TP n°5 : Gérer des événements 36 5.1 La gestion des événements 36
5.1.1 Le contrôleur de la fenêtre 36
5.1.2 Le contrôleur des contrôles 36
5.2 question de méthode 37
5.3 Exercice 37
5.4 A faire 38
5.5 Ce qu'il faut retenir 38
5.6 Vos notes 39 6 TP n°6 : Héritage et interface 40 6.1 Héritage 40
6.1.1 Une seconde visite du parking 40
6.2 Classes abstraites 42
6.3 Interface 42
6.4 Exercice 43
6.5 Ce qu'il faut retenir 43
Vos notes 43 7 TP n° 7 : Vecteurs et listes 44 7.1 Description d'un vecteur 44
7.1.1 Création d'un vecteur 44
7.1.2 Quelques méthodes 44
7.2 Concordance de types et transtypage 45
7.3 Exercice 45
7.4 Ce qu'il faut retenir 46
Vos notes 46 8 TP n°8 : L'architecture modèle - Vue - Contrôleur 47 8.1 Fonctionnement 47
8.2 Présenter des données dans des tables 48
8.3 Description des composants Listes et Tables 50
8.3.1 Les Listes 50
8.3.1.1 Constructeurs 50
8.3.1.2 Quelques méthodes 50
8.3.2 Les modèles de données « Liste » 50
8.3.2.1 L'interface ListModel 50
8.3.2.2 La classe abstraite AbstractListModel et la classe
DefaultListModel 50
8.3.3 Les Tables 51
8.3.3.1 Constructeurs 51
8.3.3.2 Quelques méthodes 52
8.3.4 Les modèles de données « Table » 52
8.3.4.1 L'interface TableModel 52
8.3.4.2 La classe abstraite AbstractTableModel et la classe
DefaultTableModel 53
8.4 Exercice 54
8.4.1 A faire 54
8.5 Ce qu'il faut retenir 55
8.6 Vos Notes 55 9 TP n°9 : Hashtables 56 9.1 Description de la classe HashTable 56
9.1.1 Constructeurs 56
9.1.2 Quelques méthodes 56
9.2 Description de l'interface Enumeration 57
9.2.1 Les méthodes 58
9.3 Exercice 58
9.4 A faire 58
9.5 Ce qu'il faut retenir 58
9.6 Vos Notes 59 10 TP n° 10 : Arbres, récursivité 60 10.1 Spécification d'un arbre 61
10.2 Exercice 62
10.2.1 A faire 63
10.3 Ce qu'il faut retenir 63
Vos Notes 63 A. Quelques Références 64 TP n° 1 : Concepts de base
1 Programmation orienté-objet Java est un langage orienté objet. Un objet est, de manière intuitive, un
ensemble de données et un ensemble de fonctions/procédures s'appliquant sur
ces données. Exemple : une calculatrice élémentaire. Les deux nombres représentent
les données et les opérations de base comme la multiplication ou la
soustraction sont les fonctions.
Les fonctions/procédures sont appelées des méthodes. Les méthodes décrivent
le comportement de l'objet. Un programme en Java est un ensemble d'objets exécutant des méthodes ou
demandant l'exécution de méthodes par les autres objets en leur envoyant
des messages. L'ensemble des objets de même type forme une classe d'objets.
2 Identifier et créer un objet Tous les objets manipulés en Java doivent être identifiés. Cette
identification permet de désigner et donc de manipuler l'objet : modifier
ses données ou demander l'exécution de méthodes. Une identification
s'effectue en mentionnant deux caractéristiques : quel est l'identifiant de
l'objet et sa classe : ClasseObjet NomObjet ; Exemple : Pour pouvoir manipuler la calculatrice, nous déclarons un
identifiant d'objet : c. Cet identifiant permettra de désigner des
objets de la classe des calculatrices. Calculatrice c ; La ligne précédente est une déclaration. Cette définition ne permet pas
d'avoir l'objet identifié par c à notre disposition, c'est-à-dire qu'on ne
peut pas, par exemple, demander à la calculatrice ayant l'identifiant c
d'effectuer une opération arithmétique. Il faut pour cela créer l'objet. La
création s'effectue à l'aide de l'opérateur new. Cette instruction fait
partie du jeu d'instructions de base du langage. Une création d'objet suit
la syntaxe suivante : NomObjet = new ClasseObjet(...) ; Exemple : Pour pouvoir manipuler la calculatrice, nous créons un objet
de la classe Calculatrice. L'objet est désigné à l'aide de
l'identifiant c. Autrement dit, c référence un objet de la classe des
calculatrices c = new Calculatrice() ;
3 Les données Les données manipulées dans un objet décrivent l'état d'un objet. Ainsi
dans un objet de la classe des thermostats, la température qui est une
valeur numérique représente la température désirée. Le comportement est lui
limiter à deux fonctionnalités : monter la température et descendre la
température. Maintenant considérons un client et ses commandes : [pic] Si nous considérons maintenant des objets de ces classes : Un client à des caractéristiques de base (nom, ville,...) qui sont du texte
et des caractéristiques plus complexes : la liste des commandes. Cette
liste est en fait un objet composé d'un ensemble de commandes. De fait,
nous voyons que chaque commande est-elle même un objet et, que chaque ligne
de commande contient deux informations : l'article et la quantité commandé.
L'article est un objet et la quantité est une valeur numérique.
4 Les classes Une classe est décrite dans un document portant l'extension .java. Ce
document ne doit contenir qu'une seule classe et le nom du document est le
même nom que celui de la classe. Exemple : Nom du fichier associé à la classe LignesDeCdes :
LignesDeCdes.java
1 Description type d'une classe Une classe est décrite à l'aide du mot-clef class : class maClasse { ... description de la classe (données + méthodes) ... } La description proprement dite, appelée corps de la classe, est spécifiée
entre accolades. Exemple : description de la classe lignes de commandes. Une ligne de
commande contient un article et une quantité commandée. L'article
s'appelle article_commande et est un objet de la classe Article. La
quantité est une valeur entière. class LignesDeCdes { Article article_commande ;
int qte_cdee ; } Dans un objet il ne peut y avoir que deux types d'attributs : > des objets,
> des valeurs primitives (qui ne sont pas des objets). 2 Données primitives Les principaux types de données primitives sont représentés dans le tableau
ci-après. |Nom |Description |
|boolean |Valeur logique (true, false)|
|char |Caractère |
|int |Entier |
|long |Entier long |
|float |Réel |
|double |Réel long |
La déclaration de variables primitives nécessite uniquement une
déclaration. Exemple : Pour pouvoir manipuler une quantité int qte ;
3 Les tableaux Les tableaux permettent de manipuler des lis