Programmation Orient e Objet en Java SMI S5 2014 2015

Université Abdelmalek Essaadi Département de Mathématiques
Faculté Des Sciences &

Tétouan Informatique
Filières
Sciences Mathématiques et Informatique
(Semestre 5)
PROGRAMMATION ORIENTEE OBJET
EN LANGAGE JAVA
Par
Mohammed Larbi Ben Maâti
Mis à jour en septembre 2014
1 Réalisé par M. L. Ben Maâti

Table des matières
PROGRAMMATION ORIENTEE OBJET EN LANGAGE JAVA ................................................. 1
Introduction ............................................................................................................................................. 1
P.O.O en langage Java ..................................................................................................................... Chapitre I

3
LES CONCEPTS DE LA PROGRAMMATION ORIENTEE OBJET ............................................ 3
I. LA PROGRAMMATION STRUCTUREE ...................................................................................... 3
II. LA PROGRAMMATION ORIENTEE OBJET............................................................................. 3

II.1. L'encapsulation........................................................................................................................... 3
II.2. La composition ........................................................................................................................... 4
II.3. Le polymorphisme ..................................................................................................................... 4
II.4. La généricité ............................................................................................................................... 5
II.5. L’héritage ................................................................................................................................... 5
II.6. L’interface .................................................................................................................................. 6
II.7. Le package ................................................................................................................................. 7
P.O.O en langage Java .................................................................................................................... Chapitre II

8
LE LANGAGE JAVA ............................................................................................................................ 8

I. APPLICATIONS ET APPLETS ........................................................................................................ 8
I.1. Application Java .......................................................................................................................... 8

I.2. Applet Java .................................................................................................................................. 9
II. INTRODUCTION A LA PROGRAMMATION ORIENTEE OBJET EN JAVA ........................ 11
II.1. Le package java.lang ................................................................................................................ 12

II.2. La classe System ...................................................................................................................... 12
III. LES COMMENTAIRES ............................................................................................................... 13
Annexe A ................................................................................................................................................ 14
INSTALLATION ET MANIPULATION DES OUTILS DU JDK.................................................. 14
I : Obtenir et installer la dernière version du JDK sous Windows .................................................. 14
II : Configurer le JDK .......................................................................................................................... 15

II.1. La variable d’environnement PATH ............................................................................................ 16

II.2. La variable d’environnement CLASSPATH ............................................................................... 18
III : Evolution du JDK ......................................................................................................................... 19
IV : Le compilateur............................................................................................................................... 20
V : L’interprète du code intermédiaire ............................................................................................... 20
VI: Le visualiseur d’applets Java ........................................................................................................ 21
Annexe B ................................................................................................................................................ 22
LES STRUCTURES DE DONNEES .................................................................................................. 22
Le package utilitaires java.util ............................................................................................................ 22
I. La classe Vector<E> ...................................................................................................................... 22
II. La classe Hashtable<K,V> ............................................................................................................ 24
III. La classe LinkedList<E> ............................................................................................................... 26
IV. La classe StringTokenizer ............................................................................................................. 28
Annexe C ................................................................................................................................................ 30
EXERCICES DE PROGRAMMATION GRAPHIQUE EN JAVA ................................................ 30
Annexe D ................................................................................................................................................ 34
EXERCICE DE CONCEPTION D'UNE APPLICATION GRAPHIQUE POUR REALISER

UNE CALCULATRICE....................................................................................................................... 34
Annexe E ................................................................................................................................................ 38
CONCEPTION D'UNE INTERFACE GARPHIQUE UTILISATEURE A L'AIDE DE GUI

BUILDER DE L'EDITEUR NetBeans ............................................................................................... 38
I. INTRODUCTION AU DEVELOPPEMENT D'INTERFACES GRAPHIQUES

UTILISATEUR A L'AIDE DU GUI Builder DE L'EDI NetBeans ................................................. 38
I.1. Conception de l'application de conversion de température degré Celsius-degré Fahrenheit ........ 39
I.2. Environnement de développement d'interfaces graphiques utilisateur de l'EDI NetBeans ........... 40
I.3. Conception de l'interface graphique utilisateur pour l'application de conversion de températures

degré Celsius-degré Fahrenheit............................................................................................................ 42
I.4. Ajustement de l'interface graphique utilisateur de l'application de conversion de températures .. 44
I.5. Ajout des fonctionnalités à l'application en traitant l’événement d’action du bouton Convertir .. 45
Bibliographie et Webographie ............................................................................................................. 47

PROGRAMMATION ORIENTEE OBJET EN LANGAGE JAVA
Introduction
Java est un langage de programmation orienté objet ressemblant au langage C++. Il a été développé
en 1991 par Sun Microsystems dans le cadre Green, groupe de recherche spécialisé dans le
développement de logiciels conçus pour contrôler des appareils électroniques.
Le but de Java à l’époque était de constituer un langage de programmation pouvant être intégré dans
les appareils électroménagers afin de pouvoir les contrôler, de les rendre interactifs, et surtout de
permettre une communication entre les appareils. Le groupe Green visait à créer une télécommande
universelle (Star 7) comprenant un système d’exploitation capable de gérer l’ensemble des appareils
électroménagers de la maison.
Au début le langage fut d’abord nommé Oak (Oak signifiant chêne), mais le groupe Green
s’aperçut ensuite que ce nom était déjà utilisé en informatique. Pour cette raison, le langage fut
rebaptisé Java en l’honneur du café (en anglais courant, Java signifie café), boisson préférée des
programmeurs, dont une partie de production provient de l’île indonésienne Java.
En 1994, l’équipe décida de mettre au point un navigateur (nommé HotJava) intégrant Java et
capable de faire fonctionner des applets, c’est-à-dire des petites applications Java qui s’exécutent
dans un navigateur Web.
En 1995, le langage de programmation Java a commencé à être connu, quand Sun Microsystems a
vendu une licence d’utilisation à la société Netscape l’autorisant à utiliser le langage Java dans son
navigateur Netscape.
Java est un langage qui a été conçu pour être :
- Portable ou multi plate-forme : un programme Java peut fonctionner de la même manière sur
des machines et des systèmes d’exploitation différents sans aucune modification (Windows,
Macintosh et sur la plupart des versions d’UNIX, dont Solaris et Linux, etc).
- Adapté à la conception de logiciels écrits pour l’Internet : il permet d’écrire des programmes
capables de fonctionner sur les pages du Word Wide Web. Ces programmes Java appelés
applets se présentent comme des images sur une page Web.

Java est un langage très proche du langage C++ étant donné qu’il a quasiment la même syntaxe.
Toutefois, Java est plus simple que le langage C++ puisqu’il n’en a pas conservé les aspects les plus
complexes.
Dans Java, toutes les caractéristiques du langage C++ qui peuvent induire à des erreurs de
programmation ont été supprimées :
1. Java ne dispose pas de pointeurs ni d’arithmétique sur les pointeurs, car ces fonctions sont
souvent source d’erreur dans des programmes ;
2. La libération dynamique de la mémoire est effectuée automatiquement, ce qui dispense le

programmeur de s’en charger ;
3. Java ne permet pas de surcharger des opérateurs ;
4. Java ne permet pas l’héritage multiple puisqu’il ne dispose que de l’héritage simple. L’héritage
multiple rend les langages de programmation difficile à apprendre et à utiliser ;
5. Java permet une meilleure gestion des erreurs (ou des exceptions) ;
6. Les chaînes et les tableaux sont représentés par des objets faisant partie intégrante du langage.

P.O.O en langage Java Chapitre I
LES CONCEPTS DE LA PROGRAMMATION ORIENTEE OBJET
I. LA PROGRAMMATION STRUCTUREE
La programmation structurée (ou classique) sépare les données et les traitements. Elle repose sur ce
qu’on nomme l’équation de Wirth :
Structures de données + Algorithmes = Programmes
Cette séparation :
- Rend les données vulnérables à des accès : elles ne sont pas protégées. Si des modifications
erronées des données sont effectuées, l’intégrité de ces données peut être altérée ;
- Rend difficile l’extensibilité et la réutilisation de logiciels ou produits existants.
II. LA PROGRAMMATION ORIENTEE OBJET
La Programmation Orientée Objet (P.O.O) est fondée sur le concept d’objet. Un objet est une
association des données et des traitements appelés méthodes agissant sur ces données :
Données Les données et les méthodes

+ = objet sont regroupées au sein de
méthode l’objet.
s
 Un objet constitue une instance (ou variable) d’une classe. Le mécanisme qui permet de créer des
objets à partir des classes s’appelle l’instanciation. Ce mécanisme permet non seulement de créer
l’objet mais aussi de l’initialiser.
 Une classe constitue une description (ou un model) d’un ensemble d’objets ayant une même
structure de données et disposant des mêmes méthodes.
Classe  ensemble (ou type de données)
Objet  élément de la classe (ou variable, on dit aussi instance de la classe)
Les concepts principaux dans la P.O.O pure sont : l’encapsulation, la composition, le
polymorphisme, la généricité et l’héritage. En plus de ces cinq concepts, le langage Java ajoute
deux autres concepts : l’interface et le package.
II.1. L'encapsulation
En P.O.O pure, les données sont encapsulées, ce qui signifie qu’il n’est pas possible d’agir
directement sur les données d’un objet, il faut obligatoirement passer par les méthodes de l’objet.
L’encapsulation de données permet de les protéger, elle constitue un moyen sûr pour préserver
l’intégrité des données. En effet, les contraintes d’intégrité (ou domaines de validité des données)
sont programmées et contrôlés dans les méthodes et il est obligatoire de passer par ces méthodes
pour modifier les données.
L’encapsulation permet la modularité et facilite la réutilisation de logiciel, en effet, les données et
les méthodes sont regroupées dans une même classe. De ce fait, une classe est considérée comme un
module indépendant qu’on peut réutiliser dans un nouveau programme.
II.2. La composition
La composition signifie que les objets peuvent être inclus les un dans les autres. Les objets sont
organisés selon la relation composé de.
Exemple :
Point
 Un point est un objet qui contient les coordonnées
(x,y) d'un point dans un plan. x : réel
y : réel
 Un cercle est un objet qui contient le rayon du
cercle et un point indiquant le centre du cercle. : Composition
On dit, qu'un objet cercle est composé d'un objet point Cercle
et d'un rayon du type primitif réel qui n'est pas un rayon : réel
objet. centre : Point
II.3. Le polymorphisme
C'est la faculté d'une méthode à s'appliquer à des objets de types différents. Grâce au
polymorphisme, il est possible de définir plusieurs méthodes différentes qui portent le même nom,
la différence entre ces méthodes se fait par rapport au nombre et aux types des paramètres.
Le polymorphisme permet l’écriture du code indépendamment des types spécifiques d’objets.
Exemples : Définition de la classe Point représentant des point dans un plan admettant un
constructeur surchargé (ou polymorphe, c'est-à-dire, qui admet plusieurs formes différentes). Le
constructeur a pour rôle d'initialiser les objets Point juste après leurs créations par l'opérateur new.
public class Point // Définition de la classe Point pour représenter des points dans un plan.
{
private float x, y; // Les composants d'un point dans un plan. Les attributs x et y sont encpsulée
public Point() // Constructeur sans paramètres : Initialise l'objet Point (0,0) origine du repère.
{
// Initialise l'abscisse et l'ordonnée de l'objet Point this qui fait appel à ce constructeur par 0.
this.x = this.y = 0;
}
public Point(float abs) // Constructeur à un paramètre : Initialise l'objet Point (abs,0).
{
// Initialise l'objet Point this qui fait appel à ce constructeur par (abs,0).
this.x = abs;
this.y = 0;
}

public Point(float abs, float ord) /* Constructeur à deux paramètres : Initialise l'objet Point
this qui fait appel à ce constructeur par (abs,ord). */
{
// Initialise l'objet Point this qui fait appel à ce constructeur par (abs,ord).
this.x = abs;
this.y = ord;
}
…
}
II.4. La généricité
La généricité (ou types paramétrés) permet d'introduire des paramètres (ou variables) de types
dans la définition d'une méthode ou d'une classe.
La généricité facilite la réutilisation de composants logiciels, elle permet aussi l’écriture du code
indépendamment des types spécifiques d'objets.
Exemple : Le package utilitaire java.util contient un ensemble de classes génériques qui

implémentent des structures de données couramment utilisées en programmation.
En particulier, la classe java.util.LinkedList<E> est une classe générique qui représente des listes
linéaires chainées d'éléments du type E quelconque. E est un paramètre de type générique (ou type
variable).
// Définition d'une liste linéaire chaînée d'éléments du type entier.

java.util.LinkedList<Integer> li = new java.util.LinkedList<Integer>();
// Définition d'une liste linéaire chaînée d'éléments du type Point.
java.util.LinkedList<Point> lp = new java.util.LinkedList<Point>();
II.5. L’héritage
L’héritage est un mécanisme de transmission de fonctionnalités (propriétés et comportement)

d'une classe vers une autre classe. Grâce à l’héritage, il devient donc possible de définir une nouvelle
classe à partir d’une classe existante, à laquelle on ajoute de nouvelles fonctionnalités, c'est-à-dire, de
nouvelles données (ou propriétés) et de nouvelles méthodes (ou comportements).
La nouvelle classe hérite les fonctionnalités de l’ancienne classe tout en le spécialisant. Dans ce cas,
la classe héritée constitue donc une généralisation alors que la classe qui dérive par héritage constitue
une spécialisation.
L’héritage organise les classes selon la relation est un.
L’héritage facilite la réutilisation et l’extensibilité de produits existants.
Exemple
Une classe Personne peut contenir le nom, le prénom, l'adresse et la date de naissance d'une
personne.
A partir de la classe Personne, on peut par exemple créer deux nouvelles classes : Etudiant et
Employé.
1. La classe Etudiant hérite les propriétés de la classe Personne auxquelles on ajoute, par exemple,
le numéro CNE (Code National d'Etudiant) et une indication si l'étudiant est boursier ou pas.
2. La classe Employé hérite aussi les propriétés de la classe Personne auxquelles on ajoute, par
exemple, le numéro et le salaire d'employé.
On dit, un étudiant est une personne et un employé est aussi une personne.
Date
jour : entier
mois : entier
année : entier
Personne
nom : chaîne : Composition
prénom : chaîne : Héritage
adresse : chaine
datenais : Date
Etudiant Employé
CNE : chaîne NEMP : entier
boursier : booléen salaire : réel
On constate aussi d'après le schéma qu'un objet de la classe Personne est composé d'un objet de la
classe Date.
II.6. L’interface
Une interface regroupe un ensemble de méthodes (ou comportements) dite abstraites, c’est-à-dire,
non implémentées. Lorsqu’une classe implémente une interface, cela indique que la classe se dote
d'un comportement supplémentaire par rapport à son comportement et à celui dont elle hérite déjà de
ses superclasses (classes dont elle dérive par héritage, c'est-à-dire, sa superclasse immédiate, la
superclasse de la superclasse, …, etc).
Certains langages de P.O.O (comme par exemple, le C++) permettent l'héritage multiple,
c'est-à-dire, qu'une classe peut hériter les fonctionnalités de plusieurs superclasses. Dans ces
langages, une classe peut donc posséder plusieurs superclasses.
En Java, l'héritage multiple n'est pas permis, en effet, pour des raisons de simplicité, Java ne permet
d'utiliser que de l'héritage simple. Dans ce cas, une classe ne peut hériter les fonctionnalités que
d'une seule superclasse.
L'héritage simple peut être restrictif, surtout quand-on veut construire une classe qui doit hériter les
fonctionnalités de plusieurs classes. Pour résoudre ce problème, Java propose d'utiliser des
interfaces, en effet, grâce aux interfaces, une classe peut combiner les comportements issus de
plusieurs interfaces.

Exemples :
En Java :
1. Les classes qui implémentent l'interface Cloneable sont clonables. Les objets de ces classes sont
donc clonables, c'est-à-dire, duplicables à l'aide d'une méthode appelée clone.
En particulier, la classe Date du package java.util représentant des dates et des heures
implémente l'interface Cloneable. Les objets Date sont donc clonables.
java.util.Date d = new java.util.Date(); /* d référence un objet Date qui contient la date et

l'heure actuelle. */
java.util.Date dr = d; /* Affectation de référence. L'objet référencé par d n'est pas dupliqué. d
et dr référencent le même objet. */
java.util.Date date = (java.util.Date) d.clone(); /* Duplication de l'objet référencé par d dans la
variable date. d et date référencent des objets
différents, mais identiques. */
2. Les classes qui implémentent l'interface Comparable<T> (du package java.lang, T est un
paramètre du type de données quelconque) sont comparables, c'est-à-dire, elles sont munies d'une
relation d'ordre permettant de comparer leurs objets. Cette interface contient une seule méthode
appelée compareTo qui permet de comparer des objets.
En particulier, la classe String du package java.lang représentant des chaînes de caractères en
Java implémente l'interface Comparable<String>. Les objets du type String sont donc
comparables, car cette classe est munie de l'ordre alphabétique permettant de comparer des objets
String.
String s1 = "abc", s2 = "efg";

int i = s1.compareTo(s2); /* Comparaison de s1 et s2. La méthode compareTo renvoie un entier
négatif si s1 est inférieur à s2, nul si s1 est égal à s2 et positif si s1 est
supérieur à s2. Ici compareTo renvoie un nombre entier négatif, car
s1 est inférieur à s2.*/
II.7. Le package
Un package permet de regrouper des classes et des interfaces. De la même manière que les classes
qui permettent d'encapsuler les données, les package peuvent être utilisés pour encapsuler des
classes. Mais un package doit obligatoirement avoir au moins une classe public accessible depuis
l'extérieur du package.
Les packages servent donc à protéger les classes, les donnés et les méthodes. Ils constituent des
modules indépendants qu'il est facile d'intégrer et de réutiliser dans un nouveau programme.

P.O.O en langage Java Chapitre II
LE LANGAGE JAVA
I. APPLICATIONS ET APPLETS
Un programme Java se compose d’un ou de plusieurs fichiers sources. Chaque fichier source peut
contenir dans l’ordre :
1. Une déclaration de package (en français, on dit paquetage) à l’aide de l’instruction package
(facultatif) ;
2. Une ou plusieurs importation(s) de package(s) à l’aide de l’instruction import (facultatif) ;
3. Une ou plusieurs déclarations de classes : au moins une est obligatoire, celle qui déclenche
l’exécution du programme Java.
En Java, il existe deux types de programmes :

1. Les applications : sont des programmes autonomes qui ont besoin seulement de la machine
virtuelle Java (ou interpréteur Java) pour qu’elles puissent s’exécuter sous un système
d’exploitation.
2. Les applets : sont des petites applications Java qui s’exécutent à l’intérieur d’une page Web,
dans un navigateur.
I.1. Application Java
Une application orientée objet Java est constituée :

- d’un ensemble (éventuellement vide) de classes définissant les structures de données et les
méthodes manipulées par l’application.
- d’une classe principale contenant la méthode main (ou programme principal), l’exécution de
l’application commence au début de la méthode main.
Une application orientée objet Java = {Classes} + une classe contenant la méthode main
La signature de la méthode main se présente toujours sous la forme suivante :

public static void main(String[] arguments)
{
// Corps de la méthode.
}
 public : signifie que la méthode main doit être accessible depuis les autres classes.
 static : indique que main est une méthode de classe.
 void : signifie que la méthode main ne retourne pas de valeur (il s’agit d’une procédure).
La méthode main admet un paramètre, qui est un tableau de chaînes de caractères. Ce paramètre est
utilisé pour les arguments de la ligne de commande du programme.

Exemple : Une application Java qui affiche une chaîne de caractères sur la console.
// Nom du fichier source : MainApp.java

// Commande de compilation : javac MainApp.java
// Commande d’exécution : java MainApp
public class MainApp
{
public static void main(String arguments[])
{
System.out.println("Bien venue dans Java");
}
}
I.2. Applet Java
De même, une applet Java est constituée :

- D’un ensemble (éventuellement vide) de classes ;
- D’une classe particulière qui dérive par héritage de la classe java.applet.Applet qui fait partie du
package java.applet. Cette sous-classe de la classe Applet représente la classe principale, c’est
elle qui déclenche l’exécution de l’applet.
Une applet Java = {Classes} + une sous-classe de la classe java.applet.Applet
Pour créer une sous-classe de la classe Applet, il faut utiliser la syntaxe suivante :
public class NomApplet extends java.applet.Applet
{
// Corps de l’applet.
}
public : signifie que la sous-classe NomApplet doit être accessible de toutes les autres classes
situées dans et en dehors de son package. Toutes les applets Java doivent être publiques.
extends : signifie que la classe NomApplet est une sous classe de la classe java.applet.Applet.
NomApplet est un nom quelconque attribué à l’applet. Pour qu’une applet fonctionne, elle doit être
incorporée dans une page Web à l’aide des balise <applet> et </applet> du langage HTML.
Exemple : Une applet Java qui affiche une chaîne de caractères dans une page Web.
// Nom du fichier source : MainApplet.java

// Commande de compilation : javac MainApplet.java
// Commande d’exécution : appletviewer MainApplet.html
import java.awt.Graphics;
public class MainApplet extends java.applet.Applet
{
public void paint(Graphics context)
{
context.drawString("Bien venue dans Java",50,100);
}
}

Pour exécuter cette applet dans un navigateur Web compatible Java ou par l'outil de ligne de
commande appletviewer, il faut créer le fichier HTML MainApplet.html suivant :
<HTML>
<HEAD>
<TITLE>Exemple d'une applet qui affiche une chaîne de caractères</TITLE>
</HEAD>
<BODY>
<APPLET CODE="MainApplet.class" WIDTH="600" HEIGHT="100">
Votre navigateur n'est pas compatible Java
</APPLET>
</BODY>
</HTML>
- Les fichiers source des applications et des applets java doivent porter l’extension .java.
- Chaque fichier source ne peut contenir qu'une seule classe publique, mais il peut aussi contenir
d'autres classes non publiques. Le nom de chacun de ces fichiers doit être le même que celui de la
classe publique qu'il contient.
Si un ficher source Java ne contient que des classes non publiques, dans ce cas, le nom de ce
fichier peut être quelconque.
- En Java, il faut respecter la casse (y compris entre le nom du fichier et le nom de la classe
publique), car, les minuscules sont différentes des majuscules.
- Pour compiler un programme Java avec le JDK (Java Development Kit), il faut utiliser l’outil de
ligne de commande javac, qui est le compilateur Java.
Un fichier source java portant le même nom que celui de la classe publique qu'il contient et ayant
l'extension .java est compilé en bytecode (code octete ou pseudo-code ou code intermédiaire)
dans un fichier portant le même nom que celui du fichier source et de la classe publique mais
avec l’extension .class.
Si le fichier source comporte la définition de plusieurs classes, le compilateur produira alors, pour
chaque classe définie dans le fichier source, un fichier de bytecode de même nom que la classe et
ayant l'extension .class.
- Java est un langage compilé et interprété. Pour exécuter une application Java, il faut utiliser la
commande java, qui est la machine virtuelle Java.
Cette machine virtuelle Java est un programme appelé aussi interpréteur, elle prend les
programmes Java compilés en bytecode et convertit les instructions du bytecode en instructions
compréhensibles par un système d’exploitation.
Le fait que Java repose sur l'intepréteur rend Java indépendant de toute plate forme (langage
multi plate-forme). Le même fichier compilé en bytecode peut fonctionner sur n’importe quel
plate--forme et système d’exploitation sur lequel une machine virtuelle Java (JVM : Java Virtual
Machine) adéquate a été installée.
Mais cela a des incidences sur les performances des programmes Java. En effet, ces programmes
interprétés s'exécutent plus lentement que les programmes écrits dans les langages compilés et
exécutés dépendants d'une plate-forme donnée telle le C et le C++.
- Pour exécuter une applet, il faut utiliser soit un navigateur compatible Java ou soit la commande
appletviewer du JDK.
Les navigateurs Web permettant d’utiliser des applets possèdent aussi une machine virtuelle Java
(JRE : Java Runtime Environnement).
II. INTRODUCTION A LA PROGRAMMATION ORIENTEE OBJET EN JAVA
Une classe Java comporte :

1. La description d’une structure de données : les attributs et leurs types de données respectifs ;
2. Les méthodes (ou comportements) pour agir sur les données.
 Les méthodes sont des fonctions qui contiennent des instructions. Les instructions sont parfois
regroupées pour constituer une instruction composée; dans ce cas, elles sont délimitées par un
couple d'accolades, { (début) et } (fin), pour former un bloc.
 Toutes les instructions en Java se terminent par le point-virgule.
 Une fois une classe est définie, on peut définir (ou créer) des variables de la classe, ces variables
sont appelées objets ou instances de la classe.
Exemple : Définition d’un type de données Complexe pour représenter des nombres complexes.
Supposons que nous voulons associer au type Complexe les deux méthodes suivantes :
 setComplexe : pour modifier un nombre complexe ;
 afficher : pour afficher un nombre complexe.
// Nom du fichier source : MainComp.java : Le nom de la classe publique.

public class MainComp // Définition de la classe principale contenant la méthode main.
{
public static void main(String[] args)
{
Complexe c = new Complexe();
/* Les parties réelle et imaginaire de c seront obtenues à partir des paramètres
args[0] et args[1] de la ligne de commande. */
float r = Float.parseFloat(args[0]); // Partie réelle d'un nombre complexe.
float i = Float.parseFloat(args[1]); // Partie imaginaire d'un nombre complexe.
c.setComplexe(r, i);
System.out.print("c = ");
c.afficher();
}
}
// Nom du fichier source : Complexe.java : Une classe public par fichier source.
public class Complexe
{
// Déclaration des attributs privés (ou encapsulés).
private float reel, imag; //Parties réelle et imaginaire d’un nombre complexe.
// Seules les méthodes de la classe peuvent accéder aux attributs privés.
public void setComplexe(float x, float y)
{
reel = x ;
imag = y ;
}
public void afficher()
{
System.out.println(reel + " + " + imag + " i");
}
}
II.1. Le package java.lang

Le package java.lang constitue le noyau du langage Java. Il contient les classes et les interfaces qui
sont fondamentales pour concevoir des programmes en langage Java. Parmi les classes du package
java.lang, il y a : Boolean, Byte, Character, Double, Float, Integer, Long, Math, Number,
Object, String, System, Thread, etc.
Les classes du package java.lang peuvent être utilisées sans les importer et sans mentionner le nom
du package devant leur nom, par exemple, il suffit d'écrire System.out.println(…); au lieu de
java.lang.System.out.println(…); pour utiliser la classe System.
Remarques :
La classe Object représente la racine de la hiérarchie d'héritage arborescente des classes de
Java. Toutes les classes Java ont pour superclasse la classe Object. De ce fait, ils héritent les
méthodes de cette classe.
Les classes Double, Float, Long et Integer sont des sous-classes de la classe Number. La
classe Number est une sous classe de la classe Objet.
Les méthodes de classe parseDouble, parseFloat, parseLong et parseInt définies
respectivement dans les classe Double, Float, Long et Integer permettent respectivement de
convertir un objet de type String (une chaîne de caractères) contenant une valeur numérique en
une valeur de type double, float, long et int.
La classe Math contient des méthodes de classe correspondant à des fonctions mathématiques
comme par exemple : l’exponentiel, le logarithme, les fonctions trigonométriques, la racine
carrée, etc.
II.2. La classe System
La classe System est contenue dans le package java.lang, elle sert à accéder au comportement de
niveau système de Java indépendamment de la plate-forme utilisée. La classe System contient trois
constantes de classe du type références à des objets :
1. System.err : représente le flux de sortie standard d'erreur, il correspond à l’écran ;
2. System.in : représente le flux d’entrée standard. Par défaut, il correspond au clavier ;
3. System.out : représente le flux de sortie standard. Par défaut, il correspond à l’écran.
 System.in est une référence à un objet de la classe InputStream. C’est une classe abstraite qui
contient des méthodes permettant de lire des octets (byte) à partir d'un flux d'entrée.
 System.err et System.out sont des références à des objets de la classe PrintStream. Cette classe
contient des méthodes permettant d’envoyer des caractères sur un flux de sortie. Parmi les
méthodes importantes des instances System.err et System.out de la classe PrintSteam, il y a :
 print : affiche son paramètre sur la sortie standard sans sauter la ligne ;
 println : affiche son paramètre sur la sortie standard et saute la ligne.
Le paramètre des méthodes print et println peut être de l’un des type suivants : boolean, char,
char[], double, float, int, long, String ou Object.

 Les classes InputStream et PrintStream sont contenues dans le package java.io. Ce dernier
contient des classes permettant d’effectuer des opérations d’entrées/sorties.
 Parmi les méthodes utiles de la classe System, il y a :
 arraycopy : sert à copier un tableau dans un autre ;
 exit : arrête l’exécution de la machine virtuelle Java ;
 gc : sert à appeler le garbage collector (le ramasse miettes) pour obliger la machine virtuelle
Java à récupérer la mémoire alloués à des objets qui ne sont plus utilisés.
Remarque : Il n’existe pas de méthode simple permettant de lire des entiers, des réels, des
caractères et des chaînes de caractères à partir du clavier. Rien que la lecture des caractères est
une opération compliquée en Java.
L'exemple suivant montre comment lire en Java un nombre entier à partir du clavier.
/* Les classes IOException, BufferedReader et InputStreamReader sont des classes contenues dans
le package java.io. Il faut les importer pour les utiliser. */
import java.io.* ; // Importation des classes du package java.io.
…
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n;
try
{
String s = br.readLine(); /* L'appel de la méthode readLine de l'objet br peut générer
l'exception d'entrée/sortie IOException. */
n = Integer.parseInt(s); /* L'appel de la méthode de classe parseInt définie dans la classe
Integer peut générer l'exception NumberFormatException. */
}
catch(IOException e) // Gestionnaire de l'exception IOException.
{
System.err.println("Erreur d'entrée/sortie : " + e.getMessage());
}
catch(NumberFormatException e) // Gestionnaire de l'exception NumberFormatException.
{
System.err.println("La valeur entrée au clavier n'est pas un nombre : " + e.getMessage());
}
III. LES COMMENTAIRES
En Java, il existe trois types de commentaires :

1. Le commentaire sur une ligne : il est représenté par deux barres obliques accolées (//). Le
commentaire peut démarrer à n'importe quel endroit et s'étend jusqu'à la fin de la ligne ;
2. Le commentaire sur plusieurs lignes : ce commentaires est délimité par les symboles /* et */.
Tous ce qui est situé entre ces deux délimiteurs est considéré comme un commentaire ;
3. Le commentaire de documentation : il commence par le symbole /** et se termine par */. Ce type
de commentaire peut ensuite être lu par l’outil javadoc du JDK pour générer automatiquement
de la documentation au format HTML.
Département de Mathématiques et Informatique
UNIVERSITE ABDELMALEK ESSAADI Filière : SMI (S5)

FACULTE DES SCIENECES DE TETOUAN
Programmation Orientée Objet en Java
Annexe A
INSTALLATION ET MANIPULATION DES OUTILS DU JDK
JDK : Java Develepment Kit (Kit de développement Java)
Le JDK englobe une série d’outils à ligne de commande conçus pour créer, compiler et tester des
programmes (applications et applets) java.
Le JDK est disponible gratuitement sur le site Web à l’adresse :
http://www.oracle.com/technetwork/java/javase/overview/index.html. Ce site Web contient
toutes les dernières informations sur Java y compris la dernière version du JDK.
Voici une liste des principaux outils du JDK :

1. Le compilateur (Java compiler) : javac ;
2. L’interpréteur du code intermédiaire (Java Language Runtime) : java;
3. Le visualiseur d’applets Java : appletviewer ;
4. Le désassembleur du fichier de classe : javap ;
5. Le débogueur : jdb ;
6. Le générateur de documentation : javadoc ;
7. Les applets de démonstration : ils fournissent des exemples intéressants et sont
accompagnées de code source : Dossier : jdk1.7.0_X\demo\applets (X est le numéro de
la mise à jour (Update) du JDK).
8. Le code source de l’API (Application and Programming Interface, interface de
programmation d’application).
I : Obtenir et installer la dernière version du JDK sous Windows

Pour télécharger et installer le JDK à partir du site Web de Sun, procéder de la manière suivante :
TP 1
1. Ouvrez le navigateur Internet Explorer ;
2. Dans le zone Adresse du navigateur, tapez l'adresse :

http://www.oracle.com/technetwork/java/javase/overview/index.html et puis Entrée ;
3. Cliquez sur l'onglet Downloads et puis sur l'image NetBeans Download JDK 7uX & NetBeans
7.Y pour télécharger le JDK 7uX avec l'éditeur de développement intégré NetBeans 7.Y (Y est
le numéro de la mise à jour (Update) de NetBeans) ;

4. Acceptez la licence d'utilisation de Java en cliquant sur le bouton radio Accept License
Agreement et puis cliquez sur jdk-7uX-nb-7_Y-windows-586-ml.exe pour lancer le
téléchargement du JDK pour Windows ;
5. Une fois le téléchargement du fichier jdk-7uX-nb-7_Y-windows-586-ml.exe est terminé, allez

dans le dossier dans lequel vous avez placé ce fichier et double-cliquez dessus pour lancer
l’installation du JDK.
Il est aussi recommandé de télécharger la documentation des API (Application Programming

Interface) du langage Java et les tutoriels de Java. Pour cela, allez dans le site :
http://www.oracle.com/technetwork/java/javase/overview/index.html
Et cliquez sur l'onglet Downloads. Faites ensuite défiler l'écran vers le haut jusqu'à ce que vous
atteigniez la partie Java SE 7 Documentation correspondant à la documentation du JDK 1.7. Cliquez
sur le bouton Download pour télécharger cette documentation.
Une fois le JDK est installé, on obtient la structure arborescente dont une partie est montrée
ci-après :
jdk1.7.0_X
README.html
COPYRIGHT
LICENSE
src.zip
…
bin demo include jre lib sample

java.exe
javac.exe
appletviewer.exe bin lib
javap.exe
javadoc.exe
…
Remarques :
Il ne faut pas oublier de jeter un coup d’œil sur la page Web README.html qui se trouve dans
le dossier jdk1.7.0_X, ce fichier contient les dernières informations sur Java.
Pour chercher de l’aide sur les différents outils du JDK, il faut suivre le lien hypertexte tool
documentation qui se trouve dans le sous paragraphe Development Tools du paragraphe
Contents of the JDKTM.
II : Configurer le JDK
Sous Windows, pour pouvoir utiliser les commandes du JDK, il faut ouvrir la fenêtre Invite de
commandes de MS-DOS en sélectionnant démarrer/Tous les programmes/Accessoires/Invite de
commandes.
Une fois la fenêtre Invite de commandes est ouverte, vous pouvez taper les commandes du JDK
dans cette fenêtre. Vous pouvez aussi vous aider des commandes MS-DOS notamment pour se
déplacer dans les dossiers du système du fichier Windows. Voici une liste des commandes MS-DOS
utiles pour travailler dans la fenêtre Invite de commande :

cd Sert à changer ou à afficher le dossier courant.
cls Efface l’écran.
copy Sert à copier un ou plusieurs fichiers d’un endroit vers un autre.
del Supprime un ou plusieurs fichiers.
dir Affiche le contenu (fichiers et dossiers) d’un dossier.
help Affiche de l’aide sur les commandes de Windows.
md Sert à créer un dossier.
path Affiche ou définit le chemin de recherche des fichiers exécutables.
rd Supprime un dossier
set Affiche, définit ou supprime les variables d’environnement Windows
Après l’installation du JDK, si vous tapez des commandes du JDK dans la fenêtre Invite de
commande, comme par exemple java -version qui affiche la version du JDK, l’erreur suivante
s’affiche dans la fenêtre :
‘java’ n’est pas reconnu en tant que commande interne ou externe, un programme exécutable ou
un fichier de commande.
Cette erreur provient du fait que le système d’exploitation Windows n’est pas parvenu à localiser le
fichier exécutable java.exe.
II.1. La variable d’environnement PATH

Pour pouvoir utiliser les outils de JDK à partir de n’importe quel dossier du disque dur, il faut
configurer la variable PATH en lui ajoutant le chemin d’accès vers le dossier jdk1.7.0\bin.
La variable d’environnement PATH contient un certain nombre de chemins séparés par des points
virgules. Ces chemins sont utilisés par Windows pour rechercher, dans le système de fichiers, les
commandes tapées dans la fenêtre Invite de commandes.
Lorsqu’une commande est tapée dans la fenêtre Invite de commande, Windows commence par
rechercher cette commande dans le dossier indiqué par le premier chemin du PATH. Si la
commande est trouvée, Windows l’exécute et la recherche s’arrête, sinon, la recherche continue dans
le deuxième chemin et ainsi de suite. Si la commande n’est trouvée nulle part dans les chemins
d’accès indiqués dans le PATH, Windows affiche un message d’erreur.
Supposons que le JDK a été installée dans le dossier C:\Program Files\Java. Il faut donc ajouter le
chemin d’accès C:\Program Files\Java\jdk1.7.0\bin dans la variable PATH. Pour cela, procédez de
la manière suivante :

TP 2
1. Sous Windows, allez dans le bureau de Windows et cliquez droit sur le poste de travail
;
2. Dans le menu contextuel qui s’affiche, sélectionnez la commande Propriétés. La boîte de
dialogue Propriétés système s’affiche ;
3. Cliquez sur l’onglet Avancé (ou sélectionnez la commande Paramètres système avancés) et puis
sur le bouton Variables d’environnement, la boîte de dialogue Variables d’environnement
s’affiche ;
4. Dans la zone Variables système, cliquez sur la

variable path pour le sélectionner ;
5. Cliquez ensuite sur le bouton Modifier de la zone
Variables système.
6. Dans la boîte de dialogue Modifier la variable

système, placez le curseur au début du texte de la zone
de texte Valeur de la variable et tapez
C:\Program Files\Java\jdk1.7.0\bin; comme indiqué
dans l’image ci-dessus.
La zone de texte Valeur de la variable ne doit pas
contenir de chemin vers une version antérieur du JDK.
Si un tel chemin existe, supprimez-le.

7. Cliquez sur OK autant de fois pour fermer toutes les boîtes de dialogues ouvertes.
8. Pour vérifier que la variable d’environnement PATH a bien été modifiée, ouvrez une nouvelle
fenêtre Invite de commandes et tapez la commande path. Le PATH doit contenir le chemin
d’accès vers les outils de JDK, c’est-à-dire. C:\Program Files\Java\jdk1.7.0\bin. Voici un
exemple de ce qu’on doit obtenir :
C:\Program files\Java\jdk1.7.0\bin;C:\WINDOWS\system32 ;C:\WINDOWS ;C:\WINDOWS\system32\Wbem
9. Tapez les commandes de JDK suivantes :

java -version
javac -version
Ces commandes permettent de vérifier que la version de l’interpréteur Java correspond bien à la
version du compilateur. Car, sinon, l’exécution des programmes Java peut poser des problèmes si
des versions différentes de Java sont installées et que la variable d'environnement path y fait
référence.
Remarque : La variable d’environnement PATH peut aussi être configurée dans le fichier système
autoexec.bat. Pour cela, procédez de la manière suivante :
1. Dans la fenêtre Invite de commandes, tapez la commande cd \ pour changer de dossier et se

placer sur la racine du disque dur C ;
2. Tapez edit autoexec.bat (ou utilisez l'éditeur de texte Bloc-Note) pour ouvrir ce fichier dans un
éditeur de texte. S’il n’existe pas, dans ce fichier, une ligne commençant par l’une des
commandes path ou set path, tapez la commande
set path=C:\Program Files\Java\jdk1.7.0_<version>\bin;%path% ;
3. Si le fichier autoexec.bat contient déjà une ligne commençant par une commande path ou
set path, tapez tout simplement le chemin C:\Program Files\Java\jdk1.7.0\bin; juste après le
signe =.
4. Le path ne doit pas contenir de chemin vers une version antérieur du JDK. Si un tel chemin
existe dans le path, Supprimez-le.
5. Enregistrez le fichier autoexec.bat en sélectionnant Fichier/Enregistrer ;
6. Quitter l’éditeur de texte par Fichier/Quitter et initialiser l’ordinateur.
II.2. La variable d’environnement CLASSPATH

Le compilateur et l’interpréteur Java utilisent la variable d’environnement CLASSPATH qui leur
indique où rechercher les classes définies par l’utilisateur.
La variable CLASSPATH contient une liste de chemins d’accès vers les dossiers contenants des
classes définies par l’utilisateur, ces chemins sont séparés par des points virgules.
Pour localiser une classe, Java recherche cette classe dans les librairies, s’il ne trouve pas, il effectue
la recherche dans les dossiers listés dans la variable d’environnement CLASSPATH.
La localisation d’une classe à partir de la variable CLASSPATH commence d’abord par la
recherche du nom du package et du nom de la classe dans le premier chemin. Si la classe n’est pas
trouvée, la recherche s’effectuera dans le deuxième chemin et ainsi de suite. Java retourne une erreur
s’il ne parvient pas à trouver le fichier de classe
Si aucune variable CLASSPATH n’est définie, Java utilise les librairies et le dossier courant pour
rechercher une classe utilisée dans un programme source.
Il n’est pas nécessaire de définir la variable CLASSPATH si les fichiers de classe sont tous placés
dans le dossier courant. Par contre, l’utilisation de cette variable devient nécessaire si les classes
définies par l’utilisateur sont placées dans des dossiers différents.
Remarque : L’option –classpath des outils javac, java, javap, jdb et javadoc du JDK sert aussi
à définir les chemins de recherche des classes définies par l’utilisateur.
Pour définir la variable CLASSPATH, il faut procéder de la manière suivante :
1. Sous Windows, procédez de la même manière que dans le TP 2 pour obtenir la boîte de dialogue
Variable d’environnement ;
2. Cliquez sur le bouton Nouveau de la zone Variables système pour ajouter une nouvelle variable.
3. Dans la boîte de dialogue Nouvelle variable système, tapez le nom de variable CLASSPATH
dans la zone de texte Nom de variable.
4. Dans la zone de texte Valeur de la variable, tapez les différents chemins d’accès vers les
dossiers contenants les classes définies par l’utilisateur, ces chemins doivent être séparés par des
points virgules.
-
5. Pour terminer, cliquez sur OK autant de fois pour fermer toutes les boîtes de dialogues.
Remarque : La variable d’environnement CLASSPATH peut aussi être configurée dans le fichier
système autoexec.bat. Pour cela, procédez de la même manière que celle utilisée pour configurer
la variable PATH (voir paragraphe II.1, page 5).
III : Evolution du JDK

En quelques années le langage Java et ses outils de développement (compilateur, interpréteur,
débogueur, etc) ont connus une extension et une amélioration considérables. Voici les versions
importantes du langage Java et du JDK :
 Java 1.0 : contient 212 classes réparties en 8 package. Cette version est toujours la plus supportée
par les navigateurs Web ;
 Java 1.1 : contient 504 classes réparties en 23 package. Cette version a apportée des améliorations
à l’interface utilisateur, à la gestion des erreurs, etc ;
 Java 1.2 : contient 1520 classes réparties en 59 package. L’évolution de la version 1.2 a été si
importante qu’on parle souvent de Java 2 à partir de la version 1.2.
 Java 1.3, 1.4, 1.5, 1.6, 1.7, … : Correction des erreurs et mises à jour.

Les numéros des versions du langage Java correspondent au logiciel de développement Java de Sun,
c’est-à-dire le JDK.
IV : Le compilateur
Le compilateur javac est utilisé pour compiler les programmes source en Java d’extension .java en
un code intermédiaire (bytecode) stocké dans un fichier de classe d’extension .class. Le compilateur
crée un fichier de classe pour chaque classe définie dans un fichier source.
Les fichiers de classe (ou d’extension .class) peuvent être exécutés par l’interprète Java, appelé aussi
machine virtuelle, désigné par la commande java.
Le compilateur Java est une commande exécutable à partir de la ligne de commande. La syntaxe de
la commande javac est :
javac Options NomFichier.java
NomFichier.java : indique le nom du fichier source à compiler.
Options : indique des options qui vont intervenir sur la façon dont le compilateur crée les fichiers de
classes Java exécutables. Voici une liste des options possibles :
-Classpath AutreChemin : impose au compilateur de ne pas tenir compte de la variable

d’environnement CLASSPATH et de lui substituer le chemin spécifié par AutreChemin.
Cela conduit le compilateur à rechercher les classes définies par l’utilisateur dans le chemin
désigné par AutreChemin.
-d Dossier : précise dans quel dossier seront stockées les classes une fois elles auront été
compilées.
-g : provoque la production de tables de déboguage pour les classes Java. Ces tables sont
utilisées par le débogueur Java.
-nowarn : cette option sert à arrêter les messages d’avertissement (warnings). Les
avertissements sont envoyés pendant la compilation sur la sortie standard pour indiquer les
problèmes qu’il pourrait y avoir dans le programme.
-verbose : produit des informations supplémentaires sur le processus de compilation. Cette
option peut être utilisée pour savoir exactement quels fichiers source sont en cours de
compilation.
-version : affiche la version du Java ou du JDK.
V : L’interprète du code intermédiaire

L’interprète du code intermédiaire aussi appelé machine virtuelle Java correspond à l’outil de ligne
de commande java. Cet interprète contient l’environnement nécessaire à l’exécution des programmes
Java.
La syntaxe de la commande java est :
java Options NomClass [arguments]
java Options -jar FichierJAR [arguments]
NomClass : spécifie le nom de la classe, sans l’extension .class, à exécuter. Si cette classe se trouve
dans un package, il faut indiquer le nom complet du package suivi du nom de la classe.
FichierJAR : spécifie le nom d’un fichier archive JAR. Avec l’option –jar, l’interpréteur Java
permet d’exécuter un fichier archive JAR.
arguments : liste d’arguments qui seront transmis à la méthode main. Les arguments sont
facultatifs.

Options : indique des options qui vont intervenir sur la façon dont l’interpréteur exécute le
programme Java. Voici une liste des options les plus importantes :
-classpath AutreChemin : indique à l’interpréteur de ne pas tenir compte de la variable

d’environnement CLASSPATH et de lui substituer les chemins spécifiés par AutreChemin.
Cela conduit l’interpréteur à rechercher les classes définies par l’utilisateur dans le chemin
désigné par AutreChemin.
-verbose (ou -v) : affiche un message sur la sortie standard à chaque fois qu’une classe Java
est chargée.
-verbose:gc : provoque l’affichage d’un message à chaque fois que le récupérateur de la
mémoire ramasse miette (garbage collector) sera invoqué. Le ramasse miette est appelé par
l’interpréteur à chaque fois qu’il faut libérer de la mémoire pour se débarrasser des objets
non référencé qui sont devenus inutiles. En Java, la libération dynamique de la mémoire se
fait automatiquement.
-version : affiche la version du Java ou du JDK.
VI: Le visualiseur d’applets Java

Le visualiseur d’applets Java correspond à la commande appletviewer, il sert à exécuter et à tester
des applets. Contrairement à un navigateur Web, l’outil JDK appletviewer n’affiche que les applets
incorporées à une page Web. Les autres éléments de la page Web ne sont pas affichés.
Pour lancer le visualiseur d’applets à partir de la ligne de commande, il faut utiliser la syntaxe
suivante :
appletviewer Options URL
URL : spécifie l’URL (Uniform Ressource Locator, Repère uniforme de ressource) d’un document
contenant une page HTML qui comporte une applet Java.
Options : indique comment va être exécutée l’applet Java. Il y a une option importante -debug qui
permet de lancer le visualiseur d’applet dans le déboguer Java.


Annexe B
LES STRUCTURES DE DONNEES
Le package utilitaires java.util

Le package utilitaires java.util comporte un ensemble de classes qui implémentent des structures de
données couramment utilisées en programmation. Parmi les classes les plus importantes du package
java.util, il y a :
I. La classe Vector<E>
La classe Vector sert à stocker des objets dans un tableau dont la taille varie de façon dynamique.
Quand l'espace mémoire initialement alloué à un objet Vertor devient entièrement occupé, la
capacité de stockage de cet objet sera augmentée en allouant dynamiquement de la mémoire pour un
autre bloc d'éléments à la fin de cet objet.
Dans la pratique, il faut fixer la capacité de stockage d'un objet Vector à la taille effectivement
nécessaire pour pouvoir insérer un grand nombre d'éléments. Cela réduira le nombre d'allocations de
la mémoire nécessaires pour augmenter la capacité de stockage de l'objet Vector avec les besoins.
Il est important de savoir que pour un objet Vector :
- La capacité de stockage désigne le nombre maximal d'éléments qu'il est possible d'insérer dans
l'objet avant qu'une nouvelle allocation dynamique de la mémoire par incrément ne soit effectuée.
- La taille indique le nombre d'éléments effectivement stockés dans un objet Vector.
- La capacité d'incrémentation indique le nombre d'éléments qui seront ajoutés à la fin de l'objet
Vector lors d'une nouvelle allocation de la mémoire.
Utilisation
1. Constructeurs
Vector();
Le constructeur sans paramètre crée un objet Vector avec une capacité initiale de 10 éléments.
Vector(int initialCapacity);
Le constructeur avec un seul paramètre crée un objet Vector avec une capacité initiale égale à la
valeur du paramètre initialCapacity.
Vector(int initialCapacity, int capacityIncrement);
Le constructeur avec deux paramètres crée un objet Vector avec une capacité initiale égale à la
valeur du paramètre initialCapacity et un incrément égal à la valeur du paramètre
capacityIncrement.

Exemple : Création d'un objet Vector d'une capacité de 100 éléments et d'un incrément de 20
éléments :
Vector V = new Vector(100,20); // Création et initialisation d'un vecteur d'objets.
Vector<String> S = new Vector<String>(); /* Création et initialisation d'un vecteur de
chaînes de caractères. */
2. Méthodes
Voici les méthodes les plus importantes de la classe Vector :
void addElement(E o) Ajoute l'objet o à la fin d'un objet Vector.

Crée un clone d'un objet Vector. Réalise une copie
Object clone()
superficielle.
Renvoie true si l'objet o se trouve dans un objet Vector et
boolean contains(Object o)
false sinon.
Renvoie l'élément qui se trouve à la position indiquée.
E elementAt(int index)
0 ≤ index < au nombre d'éléments dans le vecteur.
Renvoie la position de la première occurrence de l'objet o
int indexOf(Object o)
dans l'objet Vector qui fait appel à la méthode.
Même chose, sauf que la recherche commence à partir de
int indexOf(Object o, int index)
l'indice index
Insère l'objet o à la position index. 0 ≤ index ≤ au nombre
void insertElementAt(E o, int index)
d'éléments dans le vecteur.
boolean isEmpty() Teste si un objet Vector est vide.
Efface l'élément o d'un objet Vector. La méthode renvoie
boolean removeElement(Object o)
true si l'élément o est effacé et false sinon.
Efface l'élément d'indice index. 0 ≤ index < au nombre
boolean removeElementAt(int index)
d'éléments dans le vecteur.
Modifie l'élément qui se trouve à la position index par l'objet
boolean setElementAt(E o, int index)
o. 0 ≤ index < au nombre d'éléments dans le vecteur.
int size() Renvoie le nombre d'éléments dans le vecteur.
String toString() Convertit un objet Vector en chaîne de caractères.
Remarque : Puisque la classe Vector implémente l'interface List, les méthodes de l'interface List
peuvent être utilisées pour ajouter (add), accéder (get), supprimer (remove) et modifier (set) un
élément à un objet Vector.
Exemple : Création d'un vecteur de points dans un plan :
Point p1 = new Point(1,2);

Point p3 = new Point(-1,1);
Vector V = new Vector(); // V est un vecteur des points dans un plan.
V.addElement(p1); V.addElement(p2); // Ajout des points p1 et p2 à la fin de V.
V.insertElementAt(p3,1); // Insertion du point p3 à la position 1 après p1.
int n = V.size(); // Nombre d'éléments dans V.
System.out.println("V = " + V + "\n ");

for(int i = 0; i < n; ++i)
System.out.println((Point) V.elementAt(i));
Ce code affichera le résultat suivant

V = [(1,2), (-1,1), (10,200)]
(1,2)
(-1,1)
(10,200)
II. La classe Hashtable<K,V>

La classe Hashtable sert à implémenter une table de hachage pour stocker des couples (clé, valeur).
La clé est utilisée pour accéder rapidement à un élément de la table et cela grâce à un code de
hachage calculé à partir de la clé (par la méthode hashCode de la classe Object).
Une table de hachage constitue une sorte de dictionnaire qui fait correspondre des valeurs à des clés.
Les clés et les valeurs peuvent être des objets quelconques, mais la classe de l'objet clé doit
implémenter les méthodes hashcode et equals.
Une table de hachage possède une capacité de stockage et un taux de remplissage. Le taux de
remplissage représente une mesure en pourcentage de remplissage de la table, il est désigné par une
valeur comprise entre 0 et 1. Lorsque le taux de remplissage de la table est atteint, la capacité de
stockage de la table sera augmentée automatiquement.
Utilisation
1. Constructeurs
Hashtable();
Le constructeur sans paramètres crée un objet Hashtable avec une capacité initiale de 11 éléments et
un taux de remplissage par défaut de 0.75 (75 % de la capacité de stockage).
Hashtable(int initialCapacity);
Le constructeur avec un seul paramètre crée un objet Hashtable avec une capacité initiale égale à la
valeur du paramètre initialCapacity et un taux de remplissage par défaut de 0.75.
Hashtable(int initialCapacity, int capacityIncrement);
Le constructeur avec deux paramètres crée un objet Hashtable avec une capacité initiale égale à la
valeur du paramètre initialCapacity et un taux de remplissage égal à la valeur du paramètre
capacityIncrement.
2. Méthodes
Voici les méthodes les plus importantes de la classe Hashtable :
void clear() Supprime tous les éléments d'une Hashtable.

Crée un clone d'un objet Hashtable, mais les clés et les
Object clone()
valeurs ne sont pas clonées : Réalise une copie supérficielle.
Renvoie true si la clé key est une clé dans une table de
boolean containsKey(Object key)
hachage et false sinon.

Renvoie true si la table de hachage contient une ou plusieurs
boolean containsValue(Object value) clés correspondantes à la valeur du paramètre value, sinon,
elle renvoie false.
Renvoie l'interface Enumeration qui pourra servir à
Enumeration<V> elements() parcourir d'une manière séquentielle les valeurs d'une table de
hachage.
Renvoie l'objet valeur associé à la clé spécifiée par le
V get(Object key) paramètre key. La méthode renvoie null si la clé ne figure pas
dans la table de hachage.
Renvoie l'interface Enumeration qui pourra servir à
Enumeration<K> keys() parcourir d'une manière séquentielle les clés d'une table de
hachage.
Stocke le couple (key,value) dans une table de hachage. La
V put(K key, V value) méthode renvoie la valeur précédente correspondant à la clé
key ou null si la clé key ne figurait pas dans la table.
Efface la clé key et la valeur qui lui est associée de la table de
V remove(Object key) hachage. la méthode renvoie la valeur associée à la clé key ou
null si cette clé ne figure pas dans la table de hachage.
Renvoie le nombre d'éléments stockés dans la table de
int size()
hachage.
String toString() Convertit un objet Hashtable en chaîne de caractères.
Remarques : L'interface Enumeration offre les deux méthodes suivantes :
1. boolean hasMoreElements() : Renvoie true si l'énumération contient encore des éléments.
Si l'énumération ne contient plus d'élément, la méthode renvoie false ;
2. Object nextElement() : Renvoie l'élément suivant dans l'énumération.
Ces deux méthodes sont utiles pour parcourir d'une manière séquentielle une énumération.
Exemple : Création d'une table de hachage pour les chiffres, les clés utilisées correspondent aux
noms des chiffres :
Hashtable<String,Integer> H = new Hashtable<String,Integer>();

H.put("un", 1); // Conversion automatique de 1 en objet de la classe Integer.
H.put("deux", 2);
H.put("trois", 3);
System.out.println("H = " + H + "\n"); // Affichage de la table de hachage.
// Parcours de la table de hachage à l'aide d'une énumération.
Enumeration e = H.keys();
while (e.hasMoreElements())
{
String key = (String) e.nextElement();
System.out.println("(" + key +"," + (Integer) H.get(key) + ")");
}
H = {un=1, deux=2, trois=3}
(un,1)
(deux,2)
(trois,3)
III. La classe LinkedList<E>
La classe LinkedList sert à implémenter des listes chaînées d'objets. Elle contient des méthodes
permettant de traiter toute sorte de listes (les piles, les files et les listes).
Utilisation
1. Constructeur
LinkedeList()
Le constructeur sans paramètres crée un objet LinkedList implémentant une liste vide.
2. Méthodes
Voici les méthodes les plus importantes de la classe LinkedList :
void addFirst(E e) Ajoute l'objet e au début d'une liste.
Ajoute l'élément e en fin d'une liste. Cette méthode est identique à la
void addLast(E e)
méthode add(e) de l'interface List.
Renvoie un clone d'une liste, les éléments de la liste ne sont pas
Object clone()
clonés.
Renvoie le premier élément d'une liste. La méthode génère
E getFirst()
l'exception NoSuchElementException si la liste est vide.
Renvoie le dernier élément d'une liste. La méthode génère l'exception
E getLast()
NoSuchElementException si la liste est vide.
Efface et renvoie le premier élément d'une liste. La méthode génère
E removeFirst()
Efface et renvoie le dernier élément d'une liste. La méthode génère
E removeLast()
La classe LinkedList implémente deux interfaces importantes :

1. L'interface List qui offre des méthodes permettant de traiter des listes linéaires chaînées. Voici
les méthodes importantes de l'interface List :
boolean add(E e) Ajoute l'élément e à la fin d'une liste.
void add(int index, E e) Insère l'élément e à la position index. 0 ≤ index ≤ size().
void clear() Supprime tous les éléments d'une liste.
Si l'objet o est contenu dans une liste, la méthode renvoie
boolean contains(Object o)
true, sinon, elle renvoie false.
boolean equals(Object o) Teste d'égalité de deux listes.
Renvoie l'élément situé à la position index.
E get(int index)
0 ≤ index < size().
Renvoie l'indice de la première occurrence de l'objet o
int indexOf(Object o) dans une liste. La méthode renvoie -1, si l'objet o n'est pas
contenu dans la liste.
boolean isEmpty() Teste si une liste est vide ou non.
Efface et retourne l'élément situé à la position index.
E remove(int index)
0 ≤ index < size()
Efface la première occurrence de l'objet o dans une liste
boolean remove(Object o) index. la méthode renvoie true si l'objet o est dans la liste
et false sinon.
Modifie l'élément qui se trouve à la position index par la
E set(int index, E e) valeur de l'élément e. La méthode renvoie l'ancien élément
situé à la position index.
int size() Renvoie le nombre d'éléments stockés dans une liste.
2. L'interface Queue (structures de données gérées en FIFO : First-In-First-Out : Premier Arrivé,

Premier Servi) qui offre des méthodes permettant de gérer une file en représentation chaînée.
Renvoie sans effacer l'élément en tête d'une file (ou queue). Cette
E element() méthode diffère de la méthode peek, car, elle génère l'exception
NoSuchElementException si la file set vide.
Insert l'élément e en queue d'une file. La méthode renvoie true si
boolean offer(E e)
l'insertion est possible et false sinon.
Renvoie sans effacer l'élément en tête d'une file. A la différence de la
E peek()
méthode element, cette méthode renvoie null si la file est vide.
Renvoie et effacer l'élément en tête d'une file. Si la file est vide, la
E pool()
méthode renvoie null.
Renvoie et effacer l'élément en tête d'une file. Si la file est vide, la
E remove() méthode génère l'exception NoSuchElementException si la file est
vide.
Exemple : Utilisation de l'interface List pour créer une liste d'objets géométriques (Point, Segment
ou Triangle) :

Point p3 = new Point(-1,1);
Segment s = new Segment(p1,p2);
Triangle t = new Triangle(p1,p2,p3);
List l = new LinkedList(); /* Convertion automatique d'un objet du type LinkedList en
interface List. */
l.add(p1); l.add(p2); l.add(p3); // Ajout des points p1, p2 et p3 à la fin de la liste l.
l.add(1,s); // Insertion du segment s la position 1 après p1.
l.add(2,t); // Insertion du triangle t à la position 2 après le segment.
int n = l.size(); // Nombre d'éléments dans la liste l.
for(int i = 0; i < n; ++i)
{
Object o = l.get(i);
if(o instanceof Point)
System.out.println("L'element " + o + " d'indice " + i + " est un point.");
else
if(o instanceof Segment)
System.out.println("L'element " + o + " d'indice " + i + " est un segment.");
else
if(o instanceof Triangle)
System.out.println("L'element " + o + " d'indice " + i + " est un triangle.");
else
System.out.println("L'element " + o + " d'indice " + i + " est inconu.");
}

L'element (1,2) d'indice 0 est un point.
L'element [(1,2),(10,200)] d'indice 1 est un segment.
L'element [(1,2),(10,200),(-1,1)] d'indice 2 est un triangle.
L'element (10,200) d'indice 3 est un point.
L'element (-1,1) d'indice 4 est un point.
IV. La classe StringTokenizer

La classe StringTokenizer contient des méthodes permettant de découper une chaîne de caractères
en éléments (tokens). Le découpage est effectué en tenant compte d'un ensemble de séparateurs qui
peut être spécifié au moment de la création d'un objet StringTokenizer. Par défaut, les séparateurs
utilisés sont : l'espace, la tabulation et la fin de ligne.
Utilisation
1. Constructeurs
StringTokenizer(String str)
Le constructeur avec un seul paramètre crée un objet StringTokenizer à partir de la chaîne str en
utilisant les espaces (espace, tabulation et la fin de ligne) comme séparateurs.
StringTokenizer(String str, String delim)
Le constructeur avec deux paramètres crée un objet StringTokenizer à partir de la chaîne str en
utilisant les délimiteurs indiqués dans la chaîne delim. Chaque caractère de la chaîne delim est
utilisé comme délimiteur pour découper la chaîne str.
StringTokenizer(String str, String delim, Boolean returnDelims)
Le constructeur avec trois paramètres crée un objet StringTokenizer à partir de la chaîne str en
utilisant les délimiteurs indiqués dans la chaîne delim. Si le paramètre returnDelims est égal à true,
chaque délimiteur contenu dans la chaîne str est retourné en tant que chaîne (ou token) à un seul
caractère.
2. Méthodes
La classe StringTokenizer fournit deux méthodes importantes qui permettent d'obtenir les
différentes parties d'une chaîne l'une après l'autre :
1. La méthode hasMoreTokens indique s'il reste des éléments à extraire ;
2. La méthode nextToken renvoie l'élément suivant.

Le tableau suivant présente les méthodes les plus importantes de la classe StringTokenizer :
int countTokens() Retourne le nombre d'éléments qui restent dans une chaîne découpée.
boolean hasMoreTokens() Renvoie true si la chaîne à découper contient encore des éléments (ou
tokens). Si la chaîne ne contient plus d'élément, la méthode renvoie false.
String nextToken() Renvoie l'élément suivant dans la chaîne à découper.
Exemple : Supposons que l'on désire découper la chaîne : "[(1,2), (10,20)]" pour extraire les
coordonnée des point d'un segment. Voici comment procéder :
String str = "[(1,2), (10,20)]"; // La chaîne à découper.

String delim = " [(,)]"; // Les caractères délimiteurs sont : l'espace, '[', '(', ',', ')' et ']'.
StringTokenizer st = new StringTokenizer(str, delim);
while (st.hasMoreTokens())
{
System.out.println(st.nextToken());
}
1
2
10
20
Remarques :
La classe StringTokenizer implémente l'interface Enumeration qui offre les deux méthodes
suivantes :
1. boolean hasMoreElements() : Renvoie la même valeur que la méthode hasMoreTokens ;

2. Object nextElement() : Renvoie l'élément suivant dans la chaîne à découper (idem que
nextTokens).
String str = "[(1,2), (10,20)]"; // La chaîne à découper.

String delim = " [(,)]"; // Les caractères délimiteurs sont : l'espace, '[', '(', ',', ')' et ']'.
Enumeration en = new StringTokenizer(str, delim); // Conversion d'un objet en interface.
while (en.hasMoreElements())
{
System.out.println((String) en.nextElement());
}


Annexe C
EXERCICES DE PROGRAMMATION GRAPHIQUE EN JAVA
Exercice 1 Création d'une fenêtre cadre à partir de la clase JFrame Swing

Soit le programme Java non complet ci-après, ce programme est composé d'une seule classe
principale et public appelé Cadre qui contient la méthode main.
// Nom du fichier Cadre.java

import javax.swing.*; // Importation de toutes les classes du package javax.swing.
public class Cadre
{
{
}
}
1. En utilisant Swing, complétez ce programme afin de créer et d'affiche une fenêtre sans titre à
l'écran et cela en testant les quatre manières suivantes pour afficher une fenêtre.
i. L'affichage normal ou par défaut de la fenêtre : Par défaut une fenêtre cadre a une largeur et
une hauteur de 0 ;
ii. La fenêtre doit être affichée sous forme d'une icône ;
iii. La fenêtre doit être affichée sur la totalité de l'écran ;
Pour réaliser les types d'affichage ii et iii d'une fenêtre, il faut utiliser la méthode du
signature : void setExtendedState(int state) héritée de la classe Frame. Le paramètre state
peut prendre l'une des valeurs des constantes de classe, ICONIFIED ou MAXIMIZED_BOTH,
qui sont définies dans la classe Frame.
iv. La fenêtre doit être affichée avec une largeur de 300 pixels et une hauteur de 200 pixels :
Méthode héritée de la classe Component du signature : setSize(int width, int height) ;
v. Spécifier la position (200,200) pour l'affichage de la fenêtre : Méthode héritée de la classe
Component du signature setLocation(int x, int y).
N.B : Quand un objet JFrame est créé à l'aide de l'opérateur new, il est par défaut invisible. Pour
rendre visible l'objet JFrame, il faut utiliser la méthode setVisible(true).
2. Attribuer à la fenêtre le titre "Exemple de fenêtre cadre" : utiliser la méthode de la classe
Frame du signature setTitle(String titre).
3. Par défaut une fenêtre cadre est redimensionnable, c'est-à-dire, on peut changer sa largeur et sa
hauteur. Rendre la fenêtre non redimensionnable en utilisant la méthode du signature
setResizable(boolean resizable) héritée de la classe Frame.
4. Changer la couleur du fond de la fenêtre en lui attribuant une couleur de votre choix : Méthode
héritée de la classe Component du signature setBackground(Color c). Pour le choix de la

couleur, utiliser les constantes de classe définie dans la classe Color, comme par exemple :
black, bleu, cyan, darkGray, gray, green, ou créer une instance c de la classe Color.
- En AWT, il suffit de faire appel à la méthode setBackground(c) de l'objet Frame, avec c est
un objet Color ;
- En Swing, il faut faire appel aux deux méthodes simultanément :
getContentPane().setBackground(c); de l'objet JFrame.
5. Par défaut, lorsque l'utilisateur clic sur la case fermeture ou sélectionne la commande Fermer du
menu Système (ou tape Ctrl+F4), une fenêtre JFrame est tout simplement masquée. Pour fermer
une fenêtre JFrame et quitter l'application, appelez la méthode :
setDefaultCloseOperation(WindowConstants. EXIT_ON_CLOSE);
Exercice 2 Création d'une fenêtre qui dérive par héritage de la classe JFrame
Le programme suivant est composé de deux classes : La classe Cadre qui dérive par héritage de la
classe JFrame et la classe principale Fenetre qui contient la méthode main.
import javax.swing.*; // Importation de toutes les classes du package javax..swing.

class Cadre extends JFrame
{
}
public class Fenetre
{
{
}
}
1. Complétez ce programme en définissant un constructeur de la classe Cadre avec 5 paramètres :

la position (l'abscisse et l'ordonnée du coin haut gauche de la fenêtre cadre), la largeur, la hauteur
et le titre du cadre (les méthodes nécessaires à la programmation du constructeur sont exposées
dans le cours à la page 94).
2. Positionnez et redimensionnez la fenêtre cadre selon votre choix.
Exercice 3 Dessin du texte, des lignes, des cercles, des rectangles, etc dans
une fenêtre
Modifier le programme de l'exercice 1 pour dessiner dans une fenêtre cadre. Pour cela, il faut
redéfinir la méthode héritée de la classe Component du signature void paint(Graphic g).
a) Tracer deux axes au milieu de la fenêtre cadre : Méthode de la classe Graphics du signature
drawLine(int x1, int y1, int x2, int y2). Pour déterminer la hauteur et la largeur du cadre, utiliser
respectivement les méthodes héritée de la classe Component de signatures : int getHeight() et
int getWidth() (on peut aussi utiliser la méthode héritée de Component : Dimension getSize()) ;
b) Dessiner dans la fenêtre cadre un cercle rempli avec la couleur jaune dans le quart supérieur
gauche, un rectangle dans le quart supérieur droite, La chaîne de caractères "Dessin Graphique"
dans le quart inférieur gauche et une ligne droite entre le centre des axes et le coin bas à droite de
la fenêtre. La méthode void setColor(Color c) de la classe Graphics permet de changer la
couleur courante.

Exercice 4 Ajout de composants dans une fenêtre
Concevoir une application graphique Swing en Java qui convertie des températures du degré Celsius
vers le degré Fahrenheit. La formule permettant de faire la conversion est la suivante :
 9
F  (  C  32) .
8
L’interface graphique de l’application à développer doit ressembler à celui de l’image suivante :
L'utilisation de l'interface graphique de l'application doit être simple : il suffit d'entrer la température
en degré Celsius dans le champ de texte, cliquez sur le bouton Convertir pour visualiser le résultat
de la conversion de la température en degré Fahrenheit.
Il faut remarquer que la fenêtre de l'application possède un titre qui apparaît dans sa barre de titre et
les boutons réduction, agrandissement/restauration et fermeture. La fenêtre doit être non
redimensionnable.
Pour concevoir cette application, complétez la classe suivante :
public class ConvCelFahr extends JFrame

{
JPanel celsiusPanel = new JPanel();
JPanel fahrPanel = new JPanel();
JTextField tempTextCelsius = new JTextField("0",10);
JLabel tempLabelCelsius = new JLabel("Celsius");
JLabel tempLabelFahr = new JLabel("Fahrenheit");
JButton conversionButton = new JButton("Convertir");
…
}
Définir le constructeur de la classe permettant de :

1. D'initialiser une fenêtre ayant le titre que le constructeur reçoit en paramètre.
2. Appliquer le gestionnaire de positionnement GridLayout de 2 lignes et 1 colonne à la fenêtre de
l'application. Pour cela, il faut faire appel à :
getContentPane().setLayout(new GridLayout(2,1));
3. Ajoutez à l'aide de la méthode add le champ de texte tempTextCelsius et l'étiquette (le label)
tempLabelCelsius au panneau celsiusPanel. Procédez de la même manière pour ajouter le
bouton conversionButton et ensuite l'étiquette tempLabelFahr au panneau fahrPanel.
4. Ajouter à l'aide de la méthode add les deux panneaux celsiusPanel et fahrPanel à la fenêtre de
l'application.
5. Redimensionnez la fenêtre en lui attribuant : la position (200,100), la largeur 250 et la hauteur
100.
6. Affichez la fenêtre.
7. Ajouter le code suivant dans le constructeur de la classe ConvCelFahr. Ce code permet de créer
une classe interne anonyme qui implémente l'interface ActionListener.
Une instance de cette classe anonyme est créée par l'opérateur new, la référence de cette instance
est affectée à la variable m du type référence sur l'interface ActionListener.
Un écouteur d'événement d'action (ActionListener) est ajouté par la méthode
addActionListener au bouton conversionButton. L'objet référencé par m est transmis en
paramètre de la méthode pour désigner la classe qui prendra en charge le traitement de cet
événement.
Une fois l'événement d'action sur le bouton conversionButton est déclenché par un clic de la
souris sur le bouton, ce dernier appellera la méthode actionPerformed de l'objet référencé par la
variable m pour la traite.
ActionListener m = new ActionListener()

{
public void actionPerformed(ActionEvent e)
{
/* Le code permettant de réaliser la conversion doit être ajouté ici et affiché dans
l'étiquette tempLabelFahr. */
}
};
conversionButton.addActionListener(m);


Annexe D
EXERCICE DE CONCEPTION D'UNE APPLICATION GRAPHIQUE POUR
REALISER UNE CALCULATRICE
Concevoir une interface graphique utilisateur GUI en Swing pour représenter une calculatrice.
L'interface graphique doit comporter le menu Affichage permettant à l'utilisateur de choisir :
1. D'afficher une calculatrice scientifique, c'est-à-dire, contenant les touches numériques, les
opérations de base +, -, * et /, une touche pour le point décimal, une autre portant le signe = pour
afficher le résulta des calculs et encore une autre Effacer pour effacer l'afficheur et les fonctions
mathématiques : cos, sin, tan, exp, x^y, x^3 et x^2.
2. D'afficher une calculatrice standard, c'est-à-dire, ne contenant pas les fonctions mathématiques :
Calculatrice
Calculatrice
standard.
scientifique.
Pour concevoir cette application, complétez la classe suivante :
public class Calculatrice extends JFrame implements ActionListener

/* La classe sera chargée d'écouter et de traiter les différents événements d'action qui peuvent être générés
par les différents touches (ou boutons) de la calculatrice. */
{
JTextField afficheur = new JTextField("0"); // Champ d'affichage de la calculatrice.
JPanel touchesPanel = new JPanel(); // Pour regrouper les panneaux numPanel et foncPanel.
JPanel numPanel = new JPanel(); // Panneau pour regrouper les 10 touches numériques.
JPanel foncPanel = new JPanel(); // Panneau pour regrouper les touches des fonctions mathématiques.
JButton[] chiffres = new JButton[17]; // Les touches numériques et les opérations.
JButton[] fonctions = new JButton[6]; // Les touches de fonctions.
JMenuBar barreMenu = new JMenuBar(); // La barre de menus
JMenu affichage = new JMenu("Affichage"); // Menu affichage.
/* Options standard et scientifique du menu Affichage. Par défaut, c'est l'option scientifique qui est
sélectionnée pour afficher une calculatrice scientfique. */
JRadioButtonMenuItem standard = new JRadioButtonMenuItem("Standard", false);

JRadioButtonMenuItem scientifique = new JRadioButtonMenuItem("Scientifique", true);
String operation; // Opération binaire sélectionnée par l'utilisateur :+, -, * ou /;
float valeur; /* Première valeur tapée par l'utilisateur. Le résultat des calculs sera aussi placé
dans cette variable. */
public Calculatrice() // Pour créer l'interface graphique utilisateur.
{
super("Calculatrice");
// Les tableaux suivant sont initialisés en fonction de la disposition des touche dans les gestionnaires
de positionnement GridLayout qui seront utilisés pour créer l'interface de la calculatrice. */
String[] ch = {"7", "8", "9", "/", "4", "5","6", "*", "1", "2", "3", "-", "0", ".", "=", "+", "Effacer" };
String[] fonc = {"Exp", "ln", "sin", "x^y", "cos", "x^3", "x^2"};
…
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
}
Par défaut, Java applique aux fenêtres cadres le gestionnaire de mise en page BorderLayout. Ce
gestionnaire est approprié pour placer l'afficheur en haut (BorderLayout.NORTH).
Les panneaux numériques et de fonctions (numPanel et foncPanel) seront regroupés dans le
panneau touchesPanel qui doit être placé au centre (position par défaut ou BorderLayout.CENTER)
de la fenêtre cadre.
On appliquera aussi au panneau touchesPanel le gestionnaire de positionnement BorderLayout qui
servira à positionner respectivement le panneau numérique numPanel au centre et le panneau de
fonctions foncPanel à gauche (BorderLayout.WEST) du panneau touchesPanel.
Le gestionnaire de positionnement GridLayout permet de spécifier une grille et d'ajouter ensuite des
composants de gauche à droite et de haut en bas jusqu'à ce que la grille soit pleine. Ce gestionnaire
sera respectivement appliqué aux panneaux numPanel et foncPanel. Le premier sera subdivisé en 5
lignes et 4 colonnes et le deuxième en 4 lignes et 2 colonnes.
Ensuite des boutons seront créés avec les intitulés stockés dans les tableaux ch et fonc. Les boutons
numériques seront ajoutés au panneau numPanel et les boutons de fonctions seront ajoutés au
panneau foncPanel.
Complétez le constructeur de la classe Calculatrice en suivant les indications ci-dessous :
I. Conception de la fenêtre cadre de l'application

1. Redimensionnez la fenêtre en lui attribuant : la position (200,100), la largeur 450 et la hauteur
300. La fenêtre doit être non redimensionnable ; méthode setResizable.
La fenêtre doit se fermer quand l'utilisateur quitte l'application : setDefaultCloseOperation ;
2. Obtenir le gestionnaire de positionnement du conteneur ContentPane et lui appliquer un
espacement vertical entre les composants de 10 pixels (l'espacement horizontal ne sera pas
utilisé) :
BorderLayout layout = (BorderLayout)(getContentPane().getLayout());
layout.setVgap(10); /* Créera un espacement 10 pixels entre le champ de texte afficheur
au nord et le panneau touchePanel au centre de la fenêtre cadre. */

II. Ajout du champ de texte au nord de la fenêtre de l'application
1. Le texte doit être aligné à droite dans le champ de texte : appeler la méthode
afficheur.setHorizontalAlignment(JTextField.RIGHT); ;
2. Pour simplifier, on rendra le champ de texte non éditable afin de ne pas traiter des valeurs qui ne
sont pas des nombres et qui peuvent être introduit par l'utilisateur s'il tape directement ces valeurs
dans le champ du texte : méthode setEditable du champ de texte;
3. Ajouter (méthode add) le champ de texte afficheur au nord de la fenêtre cadre.
III. Conception des panneaux contenant les touches de la calculatrice

Par défaut, les panneaux utilisent le gestionnaire de positionnement FlowLayout, ce gestionnaire
permet de placer les composants l'un à la suite de l'autre tant qu’il y a de la place. Lorsqu'il n'y a
plus de la place, il recommence en dessous pour continuer à placer les composants. Ce
gestionnaire ne permet pas de disposer facilement les touches comme indiquées à la figure 1.
Pour réaliser la disposition de la figure 1, on va utiliser le gestionnaire de positionnement
GridLayout. Ce dernier permet de disposer les composants graphiques dans une grille.
1. Appliquer à l'aide de la méthode setLayout le gestionnaire de positionnement Gridlayout
respectivement aux panneaux numPanel et foncPanel.
- Le panneau numPanel doit être divisé en 5 lignes et 4 colonnes ;
- Le panneau foncPanel en 4 lignes et 2 colonnes.
Les espacements horizontaux et verticaux entre les boutons dans les deux panneaux doit être fixé
à 5 pixels : Utiliser le constructeur GridLayout à 4 paramètres ;
2. Créer des boutons numériques avec les intitulés indiqués dans le tableau ch. Au fur et à mesure
que ces boutons sont créés, ils doivent être stockés dans le tableau chiffres et ajoutés (méthode
add) au panneau numPanel.
Procéder de la même manière pour remplir le tableau fonctions et le panneau foncPanel. Pour les
intitulés des boutons, il faut utiliser le tableau fonc ;
3. Appliquer le gestionnaire BorderLayout au panneau touchesPannel (méthode setLayout). Ce
dernier servira à regrouper les panneaux numPanel au centre et foncPanel à l'ouest (à gauche).
Ajouter à l'aide de la méthode add les panneaux numPanel (au centre) et foncPanel (à gauche)
au panneau touchesPanel ;
4. Ajouter à l'aide de la méthode add le panneau touchesPanel au centre de la fenêtre cadre de
l'application.
IV. Ajout de la barre de menu, du menu Affichage et les éléments de menu

Scientifique et Standard
La barre de menus barreMenu, le menu affichage ainsi que les éléments de menu standard et
scientifique sont déjà créés. Il suffit maintenant d'ajouter ces composants à l'interface graphique
de l'application. Pour cela, procédez de la manière suivante :
1. Avant d'ajouter les éléments de menu scientifique et standard (qui sont des boutons radio) au
menu affichage, il faut d'abord les regrouper à l'aide d'une instance de la classe ButtonGroup.
En effet, les boutons radio doivent être exclusifs, ce qui signifie qu'un seul bouton doit être
sélectionné à tout moment. La classe ButtonGroup permet de rendre les boutons radio exclusifs.
- Créer une instance nommée groupe de la classe ButtonGroup ;
- Ajouter à l'aide de la méthode add les éléments de menu scientifique et standard à l'instance
groupe pour les regrouper ;

2. Utiliser la méthode add pour ajouter les éléments de menu scientifique et standard au menu
affichage ;
3. Utiliser la méthode add pour ajouter le menu affichage à la barre de menu barreMenu ;
4. Utiliser la méthode setJMenuBar pour ajouter la barre de menu barreMenu à la fenêtre cadre de
l'application ;
V. Ajout des fonctionnalités à l'application en traitant les événements d'action

1. Utiliser la méthode addActionListener pour ajouter l'écouteur d'événement, c'est-à-dire, une
instance de la classe Calculatrice à tous les touches ou boutons de la calculatrice ainsi qu'aux
éléments de menu scientifique et standard. Ce code doit encore être ajouté dans le constructeur
de la classe Calculatrice ;
2. Pour traiter les événements d'action qui peuvent être générés par les différents composants
graphiques (boutons et éléments de menus) de l'interface graphique utilisateur, on va charger la
Calculatrice correspondant à la fenêtre cadre de l'application d'écouter et de traiter ces
événements.
Pour cela, il faut implémenter l'interface ActionListener par la classe Calculatrice. Cette
interface contient une seule méthode appelée actionPerformed qui doit être implémentée dans la
classe Calculatrice afin de traiter les événements d'action qui peuvent provenir des touches de la
calculatrice et des éléments de menu Affichage.
Compléter la méthode actionPerformend en lui ajoutant le code nécessaire pour réaliser les
différents traitements de calcul ainsi de changement de l'apparence de la calculatrice lorsque
l'utilisateur sélectionnera l'un des éléments de menu Scientifique ou Standard.
public void actionPerformed(ActionEvent e)

{
/* La classe ActionEvent contient la méthode de signature Object getSource(); qui renvoie la
référence de l'objet qui a déclenché l'événement d'action.*/
Object o = e.getSource();
if(o instanceof JRadioButtonMenuItem)
if(o == scientifique) // Teste de références
{
if(touchesPanel.getComponentCount() == 1)
{
setBounds(100,100,450,300);
touchesPanel.add(foncPanel,BorderLayout.WEST);
}
}
else // o ==standard
{
if(touchesPanel.getComponentCount() == 2)
{
setBounds(100,100,330,300);
touchesPanel.remove(foncPanel);
touchesPanel.validate();
}
}
else // Il s'agit d'un bouton.
} // A compléter….


Annexe E
CONCEPTION D'UNE INTERFACE GARPHIQUE UTILISATEURE A L'AIDE

DE GUI BUILDER DE L'EDITEUR NetBeans
I. INTRODUCTION AU DEVELOPPEMENT D'INTERFACES GRAPHIQUES

UTILISATEUR A L'AIDE DU GUI Builder DE L'EDI NetBeans
Ce TP constitue une introduction à la programmation d’une interface graphique utilisateur (GUI : Graphical
User Interface) en utilisant les composants Swing sous l’EDI NetBeans.
Le but de ce TP est d’introduire l’API (Application Programming Interface) Swing en concevant une
application graphique simple permettant de réaliser la conversion des températures du degré Celsius vers le
degré Fahrenheit.
La conception de l’interface graphique utilisateur de cette application permet d’introduire les bases de la
programmation graphique en utilisant une partie des composants Swing disponibles. Cette conception sera
réalisée à l’aide du GUI Builder de l’EDI NetBeans. Ce dernier est un outil RAD (Rapid Application
Development) qui permet le développement rapide d’applications graphiques en Java.
GUI Builder est un outil qui permet de créer facilement des interfaces graphiques utilisateur en utilisant de la
programmation visuelle, c’est-à-dire, en dessinant l’interface à l’aide de l’opération glisser déplacer de la souris.
A partir de l'interface dessiné, GUI Builder générera automatiquement le code en Java permettant ainsi de
simplifier le développement d’applications graphique et de se concentrer sur la représentation de l’interface et la
logique de l’application plutôt que sur les détailles techniques de l’API graphique de Java.
En plus GUI Builder permet de libérer le programmeur de la complexité d’utilisation des gestionnaires de
positionnement (layout managers) d’AWT et de Swing. En effet, GUI Bulder utilise un gestionnaire de
positionnement appelé GroupLayout qui constitue une extension des autres gestionnaires de positionnement
déjà disponibles afin de pouvoir positionner plus facilement et d’une manière visuelle les composants graphiques
dans un conteneur permettant ainsi de concevoir plus facilement une interface graphique utilisateur.
L’interface graphique de l’application à développer doit ressembler à celui de l’image suivante :
Figure 1 : Interface graphique utilisateur de l’application de conversion de températures degré Celsius-degré Fahrenheit.

Une fois l'application est créée, l'utilisation de son interface est simple, il suffit d'entrer la température en degré
Celsius dans le champ de texte, cliquer sur le bouton Convertir pour visualiser le résultat de la conversion de
la température en degré Fahrenheit.
Il faut remarquer que la fenêtre de l'application possède un titre qui apparaît dans sa barre de titre et les
boutons réduction, agrandissement/restauration et fermeture.
I.1. Conception de l'application de conversion de température degré

Celsius-degré Fahrenheit
Par la suite, l'application sera développée en deux étapes :
1. Créer l'interface graphique utilisateur et organiser les différents composants graphiques Swing de la même
manière que dans l'image de l'application montrée dans la figure 1 ci-dessus ;
2. Ajouter le code nécessaire pour réaliser la conversion de la température quand l'utilisateur clique sur le
bouton Convertir.
Etape 1 : Création de l'interface graphique utilisateur
Procéder de la manière suivante pour créer le GUI :
1. Créer un nouveau projet : sélectionnez la commande File/New Project… ou cliquez sur le bouton .
Dans la zone Categorie, sélectionnez Java et puis dans la zone Projects sélectionnez Java Application ;
2. Attribuer un nom au projet : Dans la zone Project name, taper ConvCelFahr comme nom du projet.
Vous pouvez garder le choix par défaut du dossier où sera placé le projet ou choisir un autre dossier en
cliquant sur le bouton Browse.
Cliquez sur la case à cocher Create Main Class pour la désélectionner, cela évitera de créer
automatiquement une classe principale contenant la méthode main. En effet, lors de la création de la fenêtre
interface graphique utilisateur de l'application, la classe principale correspondra à cette fenêtre.
Cliquez ensuite sur le bouton Finish.
3. Ajouter un cadre (ou un formulaire) JFrame : Cliquez droit sur le nom du projet ConvCelFahr et
sélectionnez JFrame Form… dans le menu contextuel qui s'affiche. JFrame est une classe Swing qui servira
à créer la fenêtre principale de l'application.
Vous pouvez aussi sélectionner le projet ConvCelFahr et cliquez ensuite sur le bouton New File… (ou
tapez Ctrl+N, ou sélectionnée File/New File…). Dans la boîte de dialogue qui s'affiche, sélectionnez Swing
GUI Forms et ensuite JFram Form.
Dans le champ de texte Class Name, tapez le nom ConvCelFahrGUI pour le nom de la classe fenêtre. Pour
le nom du package dans lequel sera placé la classe, tapez ma.ac.fst.convcelfahr dans le champ de texte
Package. Les autres champs se rempliront automatiquement.

Cliquez sur le bouton Finish. Une fois la création de la classe ConvCelFahrGUI est terminée, NetBeans
affiche à droite la vue graphique de la classe ConvCelFahrGUI. C'est dans cette zone qu'il faut positionner et
manipuler les différents composants graphiques Swing à l’aide de l’opération glisser déplacer la souris.
Pour visualiser le code générer automatiquement par le GUI Builder, cliquez sur le bouton Source. Le
bouton Design permet de revenir vers l'interface de conception graphique (voir la figure 2).
I.2. Environnement de développement d'interfaces graphiques

utilisateur de l'EDI NetBeans
Parmi les éléments importants de l'EDI NetBeans qu'il faut comprendre pour concevoir une interface graphique
utilisateur, il y a : La palette des composants graphiques, la zone de conception graphique, l'éditeur de
propriétés et l'Inspecteur.
1. La palette des composants graphiques
La palette contient tous les composants graphiques JFC/Swing (y compris les composants AWT). A partir de
cette liste de composants, l'application de conversion de températures utilisera seulement des étiquettes JLabel
qui serviront à afficher du texte, un champ de texte JTextField qui servira à introduire du texte, ce champ de
texte sera utilisé pour introduire les températures en degré Celsius et un bouton JBouton qui servira à actionner
la conversion de la température du degré Celsius vers le degré Fahrenheit.
Mode Sélection : Permet Mode Connexion : Sert à

la sélection des gérer les événements. Il
Ce bouton sert à
composants pour les permet d’associer des
prévisualiser l'interface
organiser dans la zone de événements aux différents
graphique avant sa
conception graphique. composants graphiques.
compilation.
Bouton Source : Barre d'outils

Affiche le code supplémentaire pour
source généré par aligner et attribuer une
GUI Builder. même hauteur et une
même largeur aux
composants graphiques
sélectionnés.
Bouton Design :
Affiche l'interface
de conception
graphique.
Zone de conception
graphique.
L'Inspecteur Palette des composants

graphiques JFC/Swing.
Figure 2 : Interface de l’outil GUI Builder du développement graphique sous NetBeans.
2. La zone de conception graphique

C'est dans cette zone qu'il faut construire d'une manière visuelle l'interface graphique utilisateur. Cette zone
possède deux vues : la vue du code source (affiche le code source généré par GUI Builder) et la vue de

conception qui est affiché par défaut. Pour changer les vues, il suffit de cliquer sur les boutons Source et
Design.
Si on jette un coup d'œil sur le code source en cliquant sur le bouton Source, on constate que l'EDI NetBeans a
généré une méthode privée nommée initComponents qui initialise les différents composants de l'interface
graphique utilisateur. Cette méthode est appelée par le constructeur de la classe fenêtre représentant la fenêtre
de l'application pour l’initialiser.
La méthode initComponents réalise les traitements suivants :
 Appel la méthode : setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); qui
indique à l'application de s'arrêter lorsqu'elle est fermée.
 Configure le gestionnaire de positionnement GroupLayout pour permettre le positionnement des composants

graphiques d’une manière visuelle ;
 Redimensionne la fenêtre de l'application à son contenu en appelant la méthode pack.
3. L'éditeur de propriétés
Cet éditeur affiche les propriétés du composant actuellement sélectionné soit dans la zone de conception
graphique du GUI Builder, ou dans l'inspecteur, ou dans la fenêtre de projets Projects ou encore dans la
fenêtre de fichiers Files.
L’éditeur de propriétés permet d’éditer les propriétés de tous les composants graphiques. L’utilisation de cet
éditeur est intuitive. Il affiche une série de lignes, chaque ligne correspond à une propriété particulière d’un
composant.
Pour modifier une propriété, il suffit de cliquer sur la ligne qui lui correspond et d'éditer la nouvelle valeur de la
propriété et cela sans manipuler directement le code source.
La figure suivante montre l’éditeur de propriété de la nouvelle fenêtre JFrame ajoutée au projet. Cet éditeur
affiche les différentes propriétés de l’objet JFrame, comme par exemple le titre, la couleur de fond (background
color), la couleur du tracé (foreground color), le curseur (cursor), etc.
Figure 3 : L'éditeur de propriétés.

4. L'inspecteur
Le dernier composant utile pour concevoir une application graphique est l’inspecteur. Ce dernier offre une
représentation graphique des composants graphique visuels et non visuels utilisés dans l’application. L'affichage
est organisé sous forme d'un arbre permettant de montrer les composants contenus dans chaque conteneur
introduit dans l'application.
L'inspecteur permis aussi de savoir quel composant est actuellement édité dans la zone de conception graphique
du GUI Builder, il permet aussi d'organiser les composant dans les différents conteneurs notamment les
panneaux disponibles dans l'application et cela en utilisant l'opération glisser déplacer de la souris pour déplacer
un composant d'un panneau (ou d’un conteneur) vers un autre.
L'inspecteur peut aussi être utilisé pour éditer le texte qui doit s'afficher sur un composant et pour changer les
noms des variables correspondant aux différents composants graphiques de l'application. Pour cela, il suffit de
cliquer droit sur le composant dans l'inspecteur et de sélectionner les commandes : Edit Text et Change
Variable Name….
Figure 4 : L'inspecteur.
Remarques :
Pour changer l'intitulé d'un composant graphique, on peut aussi double-cliquer sur le composant ou modifier
la valeur de la propriété Variable name dans l'option Code de l'éditeur de propriétés.
Si l’un des éléments suivants : la palette, l’éditeur de propriétés ou l’inspecteur n’est pas affiché à l’écran, il
est possible de l’afficher en utilisant les commandes et les sous-menus du menu Window :
I.3. Conception de l'interface graphique utilisateur pour l'application

de conversion de températures degré Celsius-degré Fahrenheit
Avec GUI Builder, la conception de l'interface graphique utilisateur de l'application devient très simple, il suffit
de faire glisser déplacer les composants graphiques à partir de la palette des composants vers l'emplacement
désiré dans la zone de conception graphique. En plus, GUI Builder permet de redimensionner facilement les
composants graphiques placés dans la zone de conception graphique permettant ainsi d'obtenir l'interface
désirée.
Au fur et à mesure que les composants graphiques sont positionnés et redimensionnés dans la zone de
conception graphique GUI Builder génère le code source appropriée.

Etape 1 : Attribuer un titre à la fenêtre de l'application
1. Sélectionnez le composant JFrame dans l'inspecteur. Vous pouvez aussi cliquer à un endroit libre de la zone
de conception graphique ;
2. Dans la fenêtre des propriétés, tapez le titre Conversion Celsius à droite de la propriété title. Vous pouvez
aussi cliquer sur le petit bouton pour introduire le titre à partir d'une boîte de dialogue.
Etape 2 : Ajout de la zone de texte, des étiquettes et du bouton à la

fenêtre de l'application
1. Cliquez sur le composant graphique JTexteField de la palette et déplacez la souris vers le coin supérieur
gauche de la zone de conception graphique (vous pouvez utiliser l'opération glisser déplacer de la souris). Dès
que le composant graphique approche le coin supérieur gauche, GUI Builder affiche des lignes en pointillés
(voir la figure 5) permettant de proposer un espacement approprié du composant avec les bords de la fenêtre
de l'application. Relâchez le bouton gauche de la souris à cet endroit, on obtient le positionnement indiqué
dans l'image de droite. Le composant graphique s'entoure des poignés de redimensionnement qui servent à
redimensionner le composant ;
Figure 5 : Ajout d'un champ de texte à la zone de conception graphique.
2. Procédez de la même manière en cliquant sur le composant graphique JLabel de la palette et faites déplacer
la souris vers la zone de conception graphique pour placer l'étiquette à droite du champ de texte.
Figure 6 : Ajout d'une étiquette à la zone de conception graphique.
Ici encore, dès qu'on approche le champ de texte, GUI Builder affiche des pointillés pour suggérer un
espacement approprié entre le champ de texte et l'étiquette. Lassez un espacement de trois traits en
pointillés. Avant de relâcher le bouton gauche de la souris, il faut s'assurer que la ligne de base de texte du
l'étiquette est bien aligné avec celui du champ de texte (voir la figure 6) ;
3. Procéder de la même manière pour placer le bouton JButton à gauche en dessous du champ de texte. Lassez
un espacement de trois traits en pointillés et aligner le bouton à gauche avec le champ de champ de texte
(voir la figure 7) ;
Figure 7 : Ajout d'un bouton à la zone de conception graphique.

4. Ajoutez de la même manière la seconde étiquette en procédant de la même manière que dans 2. Placez cette
seconde étiquette à droite du bouton comme indiqué à la figure 8 ci-dessous.
Figure 8 : Ajout de la seconde étiquette.
I.4. Ajustement de l'interface graphique utilisateur de l'application

de conversion de températures
Etant donné que les différents composants graphiques de l'application sont déjà en place, il faut maintenant
ajouter la touche finale à l'application en ajustant les différents composants graphiques. Il y a plusieurs manières
différentes de réaliser ces ajustements, on va décrire un certain nombre d'entre elles.
Etape 1 : Modifier l'intitulé des composants graphiques
1. Double-cliquez sur le bord du champ de texte et effacer le texte affiché. Si vous double-cliquez à l'intérieur du
champ de texte, c'est le code de traitement de l'événement d'action du composant qui s'affiche. Une fois le
texte est effacé, tapez Entrée, le champ de texte devient vide et se rétréci comme montré à la figure 9 ;
Pour changer l'intitulé d'un composant graphique, on peut aussi procéder de l'une des manières suivante :
- Cliquez droit sur le composant graphique et sélectionnez la commande Edit Text à partir du menu
contextuel qui s'affiche ;
- Cliquez droit sur le composant graphique dans l'inspecteur et sélectionnez la commande Edit Text à
partir du menu contextuel qui s'affiche ;
- Cliquer su le composant et modifier la propriété text dans l'éditeur de propriétés.
2. Utilisez l'une des méthodes ci-dessus pour modifier les intitulés des autres composants graphiques comme
indiqués à la figure 9.
Figure 9 : Lorsque l'intitulé du champ de texte est effacé, le champ de texte se rétréci.
Etape 2 : Redimensionnement des composants graphiques
1. Pour attribuer la même largeur au champ de texte et au bouton, il faut d'abord sélectionner les deux
composants. Pour cela, cliquez sur le champ de texte pour le sélectionner et appuyez ensuite sur la touche
Shift et cliquez sur le bouton Convertir.

2. Cliquez droit sur l'un des composants sélectionnés. Dans le menu contextuel qui s'affiche, sélectionnez la
commande Same Size -> Same Width.

Avant d'effectuer ce redimensionnement, il faut s'assurer que la fenêtre JFrame de l'application n'est pas
sélectionnée, car sinon, le menu Same Size ne sera pas actif ;
3. Si les étiquettes ne sont plus alignées à gauche déplacez l'un d'entre elles pour les aligner à gauche.
Etape 3 : Ajustement de la fenêtre de l'application en effaçant

l'espace supplémentaire
1. Pointez sur le coin inférieur gauche de la fenêtre JFrame de l'application ;
2. Faites glisser déplacer ce coin vers la gauche et vers le haut pour ajuster la fenêtre à son contenu comme
indiquer à la figure 10. Il faut laisser suffisamment d'espace à droite pour que le titre de la fenêtre puisse
s'afficher entièrement à l'exécution de l'application. Il faut noter que le bouton Preview Design permet de
faire des vérifications rapidement et cela sans compiler le programme.
Figure 10 : Redimensionnement de la fenêtre de l’application.
I.5. Ajout des fonctionnalités à l'application en traitant l’événement

d’action du bouton Convertir
Cette partie consiste à attribuer des noms de variables significatifs aux différents composants graphiques de
l’application. Ensuite, il faudra ajouter un écouteur d’événement au bouton Convertir et d’ajouter le code
nécessaire pour réaliser la conversion des températures lorsque l’utilisateur clic sur le bouton Convertir.
Etape 1 : Modifier les noms des noms des variables qui ont été créés
par défaut
1. Les noms de variables générées par défaut par GUI Builder ne sont pas significatifs. Il faut donc les
modifier pour leur donner un sens.
Pour cela, cliquez droit sur chacune des composants graphiques dans l'inspecteur. Dans le menu
contextuel qui s'affiche, sélectionnez la commande Change Variable Name…. dans la boîte de dialogue
qui s'affiche, tapez les noms de variables indiqués dans la figure 11 ci-dessous.
Figure 11 : L'Inspecteur affiche les noms des variables attribués aux différents composants graphiques.
Vous pouvez aussi modifier les noms des variables des composants graphiques en procédant des deux
manières suivantes :

- Dans la zone de conception, cliquez droit sur un composant graphique et sélectionner la commande
Change Variable Name… à partir du menu contextuel qui s'affiche.
- Utiliser l'éditeur de propriétés : Pour cela, sélectionnez un composant graphique soit dans l'inspecteur
soit dans la zone de conception graphique, allez dans l'éditeur de propriétés et modifier la valeur de la
propriété Varable Name de l'onglet Code.
Etape 2 : Ajouter un écouteur d'événement d'action au bouton

Convertir
1. Dans la zone de conception graphique, cliquez sur le bouton Convertir pour le sélectionner. Il faut s'assure
que seul le bouton est sélectionné (Si la fenêtre JFrame est aussi sélectionnée, cet étape ne marchera pas).
2. Cliquez maintenant droit sur le bouton, et sélectionner Events-->Action-->ActionPerformed à partie du
menu contextuel. Cela générera le code nécessaire qui crée un écouteur d'événement, l'ajoute au bouton
Convertir et génère une méthode vide qui sera utilisée pour y ajouter le code nécessaire permettant de
traiter l'événement d'action généré par le bouton Convertir. c'est donc dans cette méthode qu'il faut placer le
code permettant de réaliser la conversion des températures du degré Celsius vers le degré Fahrenheit ;
Vous pouvez obtenir le même résultat en cliquant droit sur la variable conversionButton associée au bouton
Convertir dans l'inspecteur et sélectionner la commande Events-->Action-->ActionPerformed ;
3. Ajouter le code suivant à la méthode générée par GUI Builder :
double tempFahr = (Double.parseDouble(tempTextCelsius.getText()) * (9.0/8) + 32);
tempLabelFahr.setText(tempFahr + " Fahrenheit");
4. Utilisez l'éditeur de propriétés pour modifier l'apparence de l'application en modifiant quelques propriétés des
composants graphiques de l'application.

Bibliographie et Webographie
[1] Cay S. Horstmann, Gary Cornell, Au cœur de Java, Volume I - Notions

fondamentales. The Sun Microsystems Press, Java Series.
[2] John December, Michael Morrison et al, Java secrets d’experts. S&SM.
[3] Laura Lemay, Rogers Cadenhead, Le programmeur Java 1.2. S&SM.
[4] Livres en ligne, visitez les sites Web : www.BRUCEECKEL.COM et

www.mindview.net/Books/TIJ.
- Bruce Eckel, Chuck Allison, Thinking in Java, 3rd Edition.
- Traduction en Français, Site Web : www.penserenjava.free.fr.
[5] Pour télécharger le tutoriel de Java depuis:
- Le site d'Oracle : http://www.oracle.com/
Et suivre les liens : Dounloads > Java > Java SE > Java Resources :
Tutorials > Tutorial Resources : Download the latest Java Tutorials bundle.
- Le site : http://docs.oracle.com/javase/tutorial/
Et suivre le lien : Download the latest Java Tutorials bundle.

Programmation Orient e Objet en Java SMI S5 2014 2015

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Programmation Orient e Objet en Java SMI S5 2014 2015

Uploaded by

Copyright:

Available Formats

Université Abdelmalek Essaadi Département de Mathématiques

Faculté Des Sciences &

PROGRAMMATION ORIENTEE OBJET

Mohammed Larbi Ben Maâti

Mis à jour en septembre 2014

1 Réalisé par M. L. Ben Maâti

PROGRAMMATION ORIENTEE OBJET EN LANGAGE JAVA ................................................. 1

P.O.O en langage Java ..................................................................................................................... Chapitre I

LES CONCEPTS DE LA PROGRAMMATION ORIENTEE OBJET ............................................ 3

I. LA PROGRAMMATION STRUCTUREE ...................................................................................... 3

II. LA PROGRAMMATION ORIENTEE OBJET............................................................................. 3

P.O.O en langage Java .................................................................................................................... Chapitre II

LE LANGAGE JAVA ............................................................................................................................ 8

I.1. Application Java .......................................................................................................................... 8

II.1. Le package java.lang ................................................................................................................ 12

INSTALLATION ET MANIPULATION DES OUTILS DU JDK.................................................. 14

I : Obtenir et installer la dernière version du JDK sous Windows .................................................. 14

II : Configurer le JDK .......................................................................................................................... 15

1 Réalisé par M. L. Ben Maâti

III : Evolution du JDK ......................................................................................................................... 19

V : L’interprète du code intermédiaire ............................................................................................... 20

VI: Le visualiseur d’applets Java ........................................................................................................ 21

LES STRUCTURES DE DONNEES .................................................................................................. 22

Le package utilitaires java.util ............................................................................................................ 22

I. La classe Vector<E> ...................................................................................................................... 22

II. La classe Hashtable<K,V> ............................................................................................................ 24

III. La classe LinkedList<E> ............................................................................................................... 26

IV. La classe StringTokenizer ............................................................................................................. 28

EXERCICES DE PROGRAMMATION GRAPHIQUE EN JAVA ................................................ 30

EXERCICE DE CONCEPTION D'UNE APPLICATION GRAPHIQUE POUR REALISER

CONCEPTION D'UNE INTERFACE GARPHIQUE UTILISATEURE A L'AIDE DE GUI

I. INTRODUCTION AU DEVELOPPEMENT D'INTERFACES GRAPHIQUES

I.2. Environnement de développement d'interfaces graphiques utilisateur de l'EDI NetBeans ........... 40

I.3. Conception de l'interface graphique utilisateur pour l'application de conversion de températures

I.4. Ajustement de l'interface graphique utilisateur de l'application de conversion de températures .. 44

Bibliographie et Webographie ............................................................................................................. 47

2 Réalisé par M. L. Ben Maâti

Java est un langage qui a été conçu pour être :

1 Réalisé par M. L. Ben Maâti

2. La libération dynamique de la mémoire est effectuée automatiquement, ce qui dispense le

3. Java ne permet pas de surcharger des opérateurs ;

2 Réalisé par M. L. Ben Maâti

LES CONCEPTS DE LA PROGRAMMATION ORIENTEE OBJET

II. LA PROGRAMMATION ORIENTEE OBJET

Données Les données et les méthodes

Le polymorphisme permet l’écriture du code indépendamment des types spécifiques d’objets.

4 Réalisé par M. L. Ben Maâti

Exemple : Le package utilitaire java.util contient un ensemble de classes génériques qui

// Définition d'une liste linéaire chaînée d'éléments du type entier.

L’héritage est un mécanisme de transmission de fonctionnalités (propriétés et comportement)

L’héritage facilite la réutilisation et l’extensibilité de produits existants.

6 Réalisé par M. L. Ben Maâti

java.util.Date d = new java.util.Date(); /* d référence un objet Date qui contient la date et

String s1 = "abc", s2 = "efg";

7 Réalisé par M. L. Ben Maâti

En Java, il existe deux types de programmes :

Une application orientée objet Java est constituée :

La signature de la méthode main se présente toujours sous la forme suivante :

8 Réalisé par M. L. Ben Maâti

// Nom du fichier source : MainApp.java

I.2. Applet Java

De même, une applet Java est constituée :

// Nom du fichier source : MainApplet.java