CoursCASA 2 GSI2 v2

CONCEPTION ET ADAPTATION DES SOLUTIONS
APPLICATIVES II
Programme du cours
Cours de conception et Adaptation des Solutions Applicatives II
SOMMAIRE
CHAPITRE 0 PRINCIPE DE LA PROGRAMMATION ORIENTEE OBJET .......................................... 1
I Introduction ............................................................................................................................. 1
II Objet et classe .......................................................................................................................... 1
III Encapsulation des données ..................................................................................................... 2
IV L’HERITAGE .............................................................................................................................. 2
V Le polymorphisme ................................................................................................................... 3
VI Le Langage JAVA ...................................................................................................................... 3
VII Eléments de syntaxe du langage Java ................................................................................ 4
VII.1 Types primitifs ............................................................................................................... 4
VII.2 Déclaration des variables et objets .............................................................................. 5
VII.3 Les opérateurs Java ...................................................................................................... 6
VII.4 Commentaires ............................................................................................................... 7
VIII Les structures de contrôles ................................................................................................. 7
VIII.1 La structure if (Si).......................................................................................................... 7
VIII.2 Les choix multiples........................................................................................................ 7
VIII.3 La structure for ( pour) ................................................................................................. 8
VIII.4 La structure While (tant que) ....................................................................................... 9
VIII.5 La structure do..while (Repeter).................................................................................. 9
IX Les sous programmes .......................................................................................................... 9
CHAPITRE 1 CLASSES / PAQUETAGES .............................................................................................. 11
I Notion générale ...................................................................................................................... 11
I.1 Introduction ..................................................................................................................... 11
I.2 Encapsulation ................................................................................................................... 11
II Constructeurs ..........................................................................................................................12
III Accesseurs et mutateurs ........................................................................................................13
IV Application ..............................................................................................................................13
V Attributs final et static ........................................................................................................... 14
VI Conversion des objets en chaîne de caractères ................................................................... 14
VII Destructeurs ........................................................................................................................15
VIII Paquetages ..........................................................................................................................15
IX Classes internes ...................................................................................................................15
CHAPITRE 2 Héritage, classes abstraites et interfaces ...............................................................17
I Héritage ...................................................................................................................................17
I.1 Introduction .....................................................................................................................17
I.2 La classe Object ...............................................................................................................17
II Méthodes et classes abstraites ............................................................................................. 18
III Interfaces ................................................................................................................................ 19
IV Héritage multiple d’interface ................................................................................................ 19
CHAPITRE 3 COLLECTION ET GESTION DES EXCEPTIONS ......................................................... 20
I Les collections d’objets ......................................................................................................... 20
I.1 La classe ArrayList............................................................................................................21
I.2 La classe HashTable ........................................................................................................ 22
I.3 La classe Vector .............................................................................................................. 22
II Les Exceptions........................................................................................................................ 23
II.1 Définition ......................................................................................................................... 23
II.2 Capturer une exception.................................................................................................. 24
II.3 Définir de nouveaux types d’exceptions ....................................................................... 25
CHAHIE THOMAS PAULIN i

Cours de conception et Adaptation des Solutions Applicatives II
CHAPITRE 4 LA PERSISTENCE ...................................................................................................... 26
I Persistance via des fichiers .................................................................................................... 26
II L’API JDBC .............................................................................................................................. 27
II.1 Type de pilote JDBC ........................................................................................................ 27
II.2 Présentation des classes de l’API JDBC ......................................................................... 27
II.3 Etablir une connexion à une base de donnée ............................................................... 28
II.4 Executer des requêtes.................................................................................................... 28
II.5 Executer les requêtes précompilées ............................................................................. 29
III Les transactions ..................................................................................................................... 29
IV Les procédures et fonction stockées.................................................................................... 29
CHAPITRE 5 LES INTERFACES GRAPHIQUES ET LES EVENEMENTS (VOIR TP) ..........................31
I Introduction ............................................................................................................................31
II Les classes de SWING .............................................................................................................31
III Les boites de dialogues ......................................................................................................... 32
IV Utilisation des icones ............................................................................................................. 32
V Utilisation des JTable ............................................................................................................. 32
VI Les looks and Feel .................................................................................................................. 33
VII Les évènements.................................................................................................................. 34
VII.1 Les Interfaces de gestion d’évènements................................................................... 34
VII.2 Intercepter un évènement ......................................................................................... 35
ANNEXE I : UTILISER JAVA EN LIGNE DE COMMANDE ..................................................................... a
ANNXE II : ETUDE DE QUELQUES CLASSES JAVA ............................................................................. c
VIII LA CLASSE STRING .............................................................................................................. c
IX La classe java.lang.Math ...................................................................................................... d
X La gestion des dates ................................................................................................................ d
XI Classes enveloppantes des types primitifs ......................................................................... e
ANNEXE III : Lecture d'un texte d'une fenêtre console.....................................................................f
CHAHIE THOMAS PAULIN ii

Cours de Programmation Orientée Objet
CHAPITRE 0 PRINCIPE DE LA PROGRAMMATION ORIENTEE

OBJET
I Introduction
La programmation Orientée Objet est un paradigme (style) de programmation consistant à
assembler des briques logicielles (objets). Elle est aujourd'hui plébiscitée par un grand nombre de
développeurs !
En effet, ce type de programmation possède de nombreux avantages :
o Réutilisation du code, donc gain de temps
o Code mieux structuré, maintenance plus aisée structuration du code
La programmation orientée objet est apparue avec, pour objectifs principaux :
1) de concevoir l’organisation de grands projets informatiques autour d’entités
précisément structurés, mêlant données et fonctions (les objets) facilitant la
modélisation de concepts sophistiqués ;
2) d’améliorer la sûreté des logiciels en proposant un mécanisme simple et flexible des
données sensibles de chaque objet en ne les rendant accessibles que par le truchement
de certaines fonctions associées à l’objet (encapsulation) afin que celles-ci ne soient
pas accessibles à un programmeur inattentif ou malveillant.
3) de simplifier la réutilisation de code en permettant l’extensibilité des objets existants
(héritage) qui peuvent alors être manipulés avec les mêmes fonctions
(polymorphisme).
Les concepts fondamentaux de la POO regroupent celles de :
o Objet
o Encapsulation des données
o Classe
o Héritage
o Polymorphisme
II Objet et classe
Un objet est une entité cohérente rassemblant des données et du code travaillant sur ses
données.
o Son Identité : C'est ce qui permet d'identifier un objet parmi d'autres. Dans le code,
le nom de variable remplit cette fonction.
o Ses Propriétés (ou attributs) : Les propriétés sont les données intrinsèques de l'objet
que l'on souhaite gérer. En prenant l'exemple d'un objet Rectangle, il faudra au
minimum gérer sa longueur et sa largeur.
o Ses Méthodes : Les méthodes sont des fonctions applicables à un objet.
Une classe peut être considérée comme un moule à partir duquel on peut créer des objets.
Une classe est une structure informatique regroupant les caractéristiques et les modes de
fonctionnements d’une famille d’objets, appelés instances de la classe.
Exemple :
CHAHIE THOMAS PAULIN 1

Un Employé :
Un Complexe
III Encapsulation des données

L’encapsulation est l'un des trois grands principes du paradigme objet. Il consiste à protéger
la définition des objets. Ce principe, digne héritier des principes d'abstraction de données et
d'abstraction procédurale prône les idées suivantes :
 Un objet rassemble en lui même ses données (les attributs) et le code capable d'agir
dessus (les méthodes)
 Abstraction de données : la structure d'un objet n'est pas visible de l'extérieur, son
interface est constituée de messages invocables par un utilisateur. La réception d'un
message déclenche l'exécution de méthodes.
 Abstraction procédurale : Du point de vue de l'extérieur (c’est-à-dire en fait du client de
l’objet), l'invocation d'un message est une opération atomique. L'utilisateur n'a aucun
élément d'information sur la mécanique interne mise.
Dans les versions canoniques du paradigme objet, les services d'un objet ne sont invocables
qu’au travers de messages, lesquels sont individuellement composés de :
 Un nom
 Une liste de paramètres en entrée
 Une liste de paramètres en sortie
L’ensemble constitué du nom de la méthode et du type de chaque paramètre d’entrée
constitue sa signature
La liste des messages auxquels est capable de répondre un objet constitue son interface :
C'est la partie publique d'un objet. Tout ce qui concerne son implémentation doit rester caché à
l'utilisateur final : c'est la partie privée de l'objet.
Il est très important de cacher les détails d'implémentation des objets à l'utilisateur. En
effet, cela permet de modifier, par exemple la structure de données interne d'une classe
(remplacer un tableau par une liste chaînée) sans pour autant entraîner de modifications dans le
code de l’utilisateur, l’interface n’étant pas atteinte.
L’encapsulation est gérer à travers le niveau de visibilité. On distingue :
 Le niveau public : L’élément est visible partout
 Le niveau private : L’élément est visible uniquement à l’intérieur de l’objet
 Le niveau protected : L’élément est visible par l’objet et ses descendants.
 Le niveau package : L’élément est visible par l’objet et par celles situées dans le
même package.
IV L’HERITAGE
Il est chargé de traduire le principe naturel de Généralisation / Spécialisation. En effet, la
plupart des systèmes réels se prêtent à merveille à une classification hiérarchique des éléments
qui les composent. Il est basé sur l'idée qu'un objet spécialisé bénéficie ou hérite des
caractéristiques de l'objet le plus général auquel il rajoute ses éléments propres.
En termes de concepts objets cela se traduit de la manière suivante :

 On associe une classe au concept le plus général, nous l'appellerons classe de base
ou classe mère ou super - classe.
 Pour chaque concept spécialisé, on dérive une classe du concept de base. La nouvelle
classe est dite classe dérivée ou classe fille ou sous-classe
On parle également de relation est-un pour traduire le principe de généralisation /
spécialisation.
V Le polymorphisme
Le polymorphisme est le troisième des trois grands principes sur lequel repose le paradigme
objet. C'est assurément son aspect à la fois le plus puissant et le plus troublant. Comme son nom
l'indique le polymorphisme permet à une méthode d'adopter plusieurs formes sur des classes
différentes.
VI Le Langage JAVA
Le langage JAVA est un projet de Sun Microsystems(1991) rachetée par Oracle. La première
version apparait en 1995. Aujourd’hui, JAVA est un langage permettant de gérer :
 La connectivité aux bases de données et les objets distribués
 Les évènements, l’internationalisation
 Le graphisme, la sécurité.
JAVA est un langage qui possède de nombreux avantages. Les principaux sont
 interruptible : il dispose d’un gestionnaire d’exceptions améliorant la robustesse et la
lisibilité des programmes ;
 à ramasse-miette : la mémoire est gérée automatiquement par le langage ;
 sécurisé: de nombreux garde-fous (encapsulation, exceptions, gestionnaire de
sécurité,…) contribuent à la robustesse des programmes, tant à la compilation qu’à
l’exécution ;
 multithread : des processus légers peuvent s’exécuter en parallèle, ce qui est
particulièrement utile dans le cas de la programmation de serveurs ou de la
parallélisassions multiprocesseurs ;
 surchargeable : les fonctions peuvent avoir le même nom et des arguments de type
différent, ce qui permet de rapprocher la conception abstraite de l’implémentation ;
 portable : grâce à l’existence d’une machine virtuelle et à une conception globale
propice à la programmation graphique et événementielle utilisable sur toute
plateforme et à l’existence d’une multitude de bibliothèques standard ;
 proche de C et C++ : la syntaxe de Java ne désoriente pas les programmeurs habitués à
ces langages ; l’interfaçage des programmes étant, par ailleurs, possible ;
 international : les programmes Java supportent les normes internationales Unicode
pour le codage des caractères de toutes les langues ;
 riche : il existe de nombreuses bibliothèques dans tous les domaines ; celles-ci ont
l’avantage considérable d’être standardisées ;
 interconnectable: certains programmes Java (les applets) peuvent être directement
intégrées dans les pages Web afin de les rendre dynamiques ; de nombreuses
bibliothèques standard permettent de travailler en réseau ;
 populaire : en particulier en entreprise, le langage Java est un investissement pour celui
qui l’apprend.
Java souffre toutefois d’un certain nombre d’inconvénients, en particulier :
 lent : même lors de l’utilisation d’un compilateur natif ;

 absence d’héritage multiple : à la différence de C++, bien que cette carence soit
compensée par un mécanisme d’interfaces ;
JAVA est un langage portable. Il a été conçu pour s’exécuter sur n’importe quelle
architecture. La portabilité est assurée par la Machine Virtuelle Java (JVM : Java Virtual Machine)
qui elle dépend de l’architecture matérielle.
La compilation d’un programme consiste à transformer les fichiers sources du programme
(fichier d’extension .java) sous une forme intermédiaire appelée bytecode. Le bytecode qui est
contenue dans un fichier .class sera interprété par la machine virtuelle Java en code directement
exécutable par l’ordinateur. Ceci fait de Java un langage Compilé(génération du bytecode ou du
fichier .class) et interprété(Interprétation du byte code au moment de l’exécution).
La compilation d’un fichier source (.java) génère un fichier de même nom et d’extension
.class.
La compilation se fait à l’aide de la commande javac. Il faut noter que le nom du fichier et
l’extension sont obligatoires.
Ex. javac Gestion.java . Cette commande compile le fichier Gestion.java et génère le fichier
Gestion.class.
L’exécution se fait à l’aide de la commande java. Au moment de l’exécution l’extension du
fichier n’est plus demandée.
Ex. java Gestion
Pour développer en Java l’utilisateur doit :
 Télécharger et installez la machine virtuelle Java
 Télécharger et installer un éditeur de code Java (bloc notes, NOTEPAD, …) ou un
environnement de développement Java (Eclipse, JBuilder, NetBeans, …)
VII Eléments de syntaxe du langage Java
VII.1 Types primitifs

Les types primitifs de Java sont, en quelque sorte, les « composants atomiques » avec
lesquels on construit des classes en Java.
Les types non-primitifs sont désignés implicitement par leur référence en mémoire. Il s’agit
des instances de classes, dont les tableaux de type primitif, ou non, font partie. La valeur null
désigne une référence qui ne correspond à rien.
Les types prédéfinis sont définies dans le tableau ci-dessous.
Nom Représentation Minimum Maximum
boolean 1 bit true , false
char 16 bits Unicode UTF-16, 2.1
byte 8 bits, signée
short 16 bits, signée
int 32 bits, signée -2 147 483 648 2 147 483 647
long 64 bits, signée - 9 223 372 036 854 775 9 223 372 036 854 775 807
808
float 32 bits, signée IEEE Float.MIN_VALUE Float.MAX_VALUE
double 64 bits, signée IEEE
Tableau 0-1: Tableau des types primitifs Java

VII.2 Déclaration des variables et objets
Par convention en plus des règles algorithmes sur le nom des identificateurs, le nom d’une
variable commence par une lettre minuscule. Si le nom de la variable est composé, alors la
première de chacun des éléments qui compose la variable (à l’exception de la première lettre)
commence par une lettre majuscule.
Pour faire simple, la déclaration d’une variable ou d’un objet s’effectue comme suit :
NomType_ou_Classe ListedesElements ;
Où :
- NomType_ou_Classe : Représente le nom de type ou de la classe de l’objet
- ListeDesElements : Représente la liste des variables ou objets séparées par des virgules.
Attention : Java gère la casse, il faut en tenir compte au moment de la déclaration des
identificateurs. L’identificateur nom est différent de Nom
Exemples :
int age,taille ;
char sexe ;
Il est possible d’initialiser une variable au moment de la déclaration.
Exemple:
int mois=12 , annee=2009 ;
Pour la déclaration des tableaux on utilise l’instruction
int[4][6] x : pour la déclaration d’un tableau à 4 lignes et 6 colonnes. Il est à noter que les
indices d’un tableau commencent toujours par 0. Ainsi les indices de la première dimension iront
de 0 à 3 et ceux de la seconde dimension de 0 à 5.
Plus généralement l’utilisation des tableaux passe par deux étapes :
 Une phase de déclaration ou on définit le nom de la variable et le nombre de
dimension de celle-ci. Pour ce faire on utilise les crochets placés après le nom de la
variable ou du type:
typeRef nomVar[]…[] ou typeRef[]…[] nomVar;
Ex : int x[]//déclare un tableau de dimension 1 d’entier.
 Une phase de dimensionnement ou il sera question de définir la taille de chaque
dimension. La taille de chaque dimension peut être une variable. Toutefois,
lorsqu’un tableau est dimensionné, le nombre d’élément dans chaque dimension
est fixé une fois pour toute.
Pour redimensionner on utilise nomVar=new TypeRef[taille1]……[taillen] ;
Ex : x=new int[20] ;
Pour avoir le nombre d’élément d’un tableau, on utilise la méthode length de l’objet
comme suit « nomVar.length ».
Remarque :

int t21[][] = {{1, 2, 3}, {4, 5, 6}};

définit un tableau dont la première dimension va de
l'indice 0 à l'indice 1 et la deuxième dimension de l'indice
0 à l'indice 2.
Toutes les lignes d’un tableau à 2 dimensions n’ont pas

forcément le même nombre d’éléments :
int t22[][] ;
t22 = new int[5][];
for( int i = 0; i< t22.length; ++i){
t22[i]= new int [i+1];
}
for( int i = 0; i< t22.length; ++i){
for( int j = 0; j<t22[i].length; ++j){
//accès à t22[i][j]
}
}
VII.3 Les opérateurs Java

Un identificateur sous Java a une portée limitée au bloc dans lequel il est déclaré. Sous Java,
un bloc commence par une accolade ouvrante et se termine par une accolade fermante.
Les différents opérateurs de Java sont consignés dans le tableau ci-dessous. Attention,
l’affectation, l’égalité et la différence ont une sémantique de valeur pour les types primitifs mais
une sémantique de référence pour les types référencés.
Syntaxe Sémantique
x=y affectation (x prend la même valeur que celle de y)
x==y (test d’égalité) vrai si x = y, faux sinon
x != y (test de différence) faux si x = y, vrai sinon
x<y infériorité stricte (vrai si x<y)
x>y supériorité stricte (vrai si x>y)
x <= y infériorité large (vrai si x<=y)

x >= y Supériorité large (vrai si x>=y)
x+y Addition
x-y Soustraction
x *y Multiplication
x/y Division
x%y x modulo y
++x Pré incrémentation
- -x Pré décrémentation
x++ Post incrémentation
x- - Post décrémentation
x op =y Où op est un opérateur : x= x op y
! Négation logique
x && y Et logique
x || y Ou logique
x&y conjonction logique bit à bit d’entiers
x|y disjonction logique bit à bit d’entiers
~x négation logique bit à bit d’entier
^x disjonction exclusive (xor) bit à bit d’entier
x<<n décalage à gauche des bits de x (0 à droite)
x>>n décalage à droite des bits de x (0 à gauche)
(T)x transtype x vers le type T (si possible)
Tableau 2: Opérations de base du langage
Opérateur ternaire :
Cond ?a :b
Si cond est vrai alors a sinon b.
Exemple :
x=(a>b ?a :b) permet de calculer le plus grand entre a et b.
VII.4 Commentaires
Sous Java, il existe deux types de commentaires. Les commentaires servant à expliquer le
code ainsi que les commentaires utilisés dans le cadre de la documentation du code (JAVADOC).
Les commentaires servant à expliquer le code sont placés après « // » si le commentaire tient
sur une ligne, et entre « /* */ » si celui-ci tient sur plusieurs lignes.
Ex :
// ceci est un commentaire sur une ligne
/* Ceci est le début du commentaire qui commence sur cette ligne
Continue sur celle-ci
Et se termine ici */
Pour la génération de la JavaDoc, le commentaire est placé entre « /**…*/ ».
Ex:
/** ici se trouve le code de la JavaDoc*/
VIII Les structures de contrôles

Un bloc d’instruction sous Java commence par un «{» « et se termine par un « }. ».
La syntaxe des instructions Java est assez proche de celle du C.
VIII.1 La structure if (Si)

if(test){
if(test){ partie à exécuter si test est vrai ;
partie à exécuter si test est vrai ; }else{
} partie à exécuter si test est faux ;
avec la variante : }
VIII.2 Les choix multiples

Pour une variable x dont le type est byte, char, short et int, Java dispose aussi de
l’instruction switch : Il correspond à l’instruction de sélection multiple case du Pascal.
La syntaxe est :
switch(x){
case a1:
partie à exécuter si x = a1 ;

break;
.
case an:
partie à exécuter si x = an ;
break;
default: // Optionnel mais fortement recommandé partie si x n’est aucune des valeurs a1, …, an
}
Notons que dans la définition précédente que chaque instruction case se termine par une
instruction break, qui provoque un saut à la fin du corps de l'instruction switch. Ceci est la
manière habituelle de construire une instruction switch.
Cependant break est optionnel. S'il n'est pas là, le code associé à l'instruction case
suivante est exécuté, et ainsi de suite jusqu'à la rencontre d'une instruction break. Bien qu'on
n'ait généralement pas besoin d'utiliser cette possibilité, elle peut se montrer très utile pour un
programmeur expérimenté. La dernière instruction, qui suit default, n'a pas besoin de break car
en fait l'exécution continue juste à l'endroit où une instruction break l'aurait amenée de toute
façon. Il n'y a cependant aucun problème à terminer l'instruction default par une instruction
break si on pense que le style de programmation est une question importante.
Ex : switch(c) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
case 'y':
System.out.println("vowel");
break;
default:
System.out.println("consonant");
}
VIII.3 La structure for ( pour)

La syntaxe est la même que celle du C. ´ Etant donnée une variable de boucle i :
for(état initial de i ; test sur i ; transformation de i){
corps de la boucle àexécuter si test est vrai ;
}
La transformation sur i est souvent une opération d’incrémentation : i++ (resp. ++i), faite
après (resp. avant) le passage dans la boucle, ou de décrémentation : i-- (resp. --i), faite après
(resp. avant) le passage dans la boucle. On peut définir localement la variable de boucle : par
exemple for(int i=0;i<10;i++).
Lorsqu’on est en face d’une collection c dont les elements sont de type T on peut utiliser
for(T x :c){
//traitement de x;
}

VIII.4 La structure While (tant que)
La syntaxe est la même que celle du C :
while (test){
corps de la boucle à exécuter si test est vrai ;
}
VIII.5 La structure do..while (Repeter)

La syntaxe est
do{
corps de la boucle à exécuter ;
}while(test);
qui permet d’exécuter le corps une première fois avant de faire le test, ce qui est pratique
dans certains cas.
Le déroulement de toutes les instructions d'itération peut être contrôlé de l'intérieur du
corps de la boucle au moyen des instructions break et continue. L'instruction break sort de la
boucle sans exécuter la suite des instructions. L'instruction continue arrête l'exécution de
l'itération courante, et l'exécution reprend en début de boucle avec l'itération suivante.
IX Les sous programmes

Tout comme le C, le seul type de sous-programme sous Java est la fonction. Un sous-
programme (voir méthode) à la forme :
TypeRetour nomFonction(ListeArgument){
Corps du sous programme
}
Si le sous-programme ne renvoie aucune valeur, le type de retour est void (Procédure) de
même, si le sous-programme n’a pas d’argument, le type d’entrée est void.
boolean egalite(int[] x, int[] y){
int n=x.length;
if (n != y.length) return false;
boolean b = true;
for(int j=0; j<n;j++){
if (x[j] != y[j]){
b = false;
break;
}
}
return b;
}
Une méthode particulière, la méthode main est utilisée par la machine virtuelle pour
lancer l’exécution d’une classe. Sa syntaxe est :
public static void main(String[] args) {

}
Ici args représente les arguments qui seront passé au moment du lancement de la classe
contenant le main.

CHAPITRE 1 CLASSES / PAQUETAGES
I Notion générale
I.1 Introduction
La notion de classe généralise la notion de type. La classe comporte des champs
(données) et des fonctions appelées méthodes.
L’accès à ces attributs est limité par un certain nombre de mot-clé dont le principal est la
visibilité. Ces éléments sont définis dans une zone délimitée par des accolades, précédée par le
mot class.
Pour éviter les ambiguïtés, on peut préciser qu’on fait référence à l’instance courante en
déréférençant les attributs à partir de this.
La syntaxe minimale de création d’une classe est :
[public |public] class nomClasse{
//définition des attributs
//définition des méthodes
}
La syntaxe minimale de déclaration d’un attribut est la suivante :
[visibilite] typeattribut[=valeurDefaut] [,typeattribut[=valeurDefaut]]
La syntaxe minimale de déclaration d’une méthode est :
[visibilite] typeRetour nomMethode( listeParametre)
I.2 Encapsulation
La visibilité permet de définir le niveau d’encapsulation et l’intégrité des éléments d’une
classe. Divers mots-clés paramètrent le niveau d’encapsulation des attributs :
1. private : accès depuis la classe uniquement ;
 Pour un champ : c’est un choix restrictif car il empêche aux classes héritières
de l’utiliser directement ; l’accès, toujours possible par des accesseurs et des
mutateurs, est plus sûr mais moins efficace (c’est le niveau conseillé);
 Pour une méthode : c’est une pratique courante, par exemple, pour des
méthodes auxiliaires qui n’ont pas vocation à être visibles de l’extérieur de la
classe, ni même par les héritières qui utiliseront une autre méthode qui leur
sera accessible ;
2. package : accès depuis les classes du package uniquement (valeur par défaut) ;
 pour un champ : c’est un choix pratique, à condition de bien délimiter ses
packages ;
 pour une méthode : idem;
3. protected : accès depuis toutes les classes du package et des héritières,
uniquement ;
 pour un champ : c’est un choix pratique qui va dans le sens de l’efficacité mais
qui peut poser des problèmes de sécurités i un utilisateur de la classe détruit sa
cohérence interne en agissant directement sur les champs sans passer par les
accesseurs et les mutateurs ;
 pour une méthode : c’est un paramétrage minimal pour que les classes
héritières puissent en bénéficier directement ;

4. public : accès depuis partout où le paquetage est accessible :
 pour un champ : c’est un choix qui doit rester très exceptionnel car il va à
l’encontre de la philosophie d’encapsulation ;
 pour une méthode : c’est le paramétrage des méthodes qui permettent à la
classe d’interagir avec le reste des objets, quels qu’ils soient ;
 pour une classe : c’est la façon de rendre la classe utilisable en dehors du
paquetage
Remarques :
Dans une classe, plusieurs méthodes peuvent avoir le même nom à condition d’avoir des
signatures différentes.
Lors de la création d’une classe X, JAVA ajoute un constructeur par défaut permettant de
créer les instances de cette classe. La création d’une instance se fait en utilisant le bout de code
X x=new X() ;
Les champs c et les méthodes f d’un objet m sont identifiés par l’expression m.c et
m.f(…). Ces méthodes sont à utiliser en fonction de leurs visibilité.
Application :
Considérons un point en dimension 2. Chaque point est caractérisé par son abscisse et
son ordonné et une méthode distance qui permet de calculer la distance entre deux points.
class Point{
// abscisse et ordonnée entières, privées:
private int x,y;
// Méthode qui calcule ladistance
Public double distance(Point p){
double dx=
double dz=
return
}
}
int a,b;
Du fait que x et y sont des champs private de point, de l’extérieur de la classe Point on ne
peut écrire
int a,b;
a = p.x; // provoque une erreur à la compilation
b = p.y; // provoque une erreur à la compilation
La syntaxe de création d’une instance est : //pour l’instant

Point o = new Point(); // l’origine
II Constructeurs
Un constructeur est une méthode dont le nom est identique à celui de la classe et qui n’a
pas de type de retour (même pas void). Cette méthode est utilisée pour créer les instances
d’une classe.
Lors de la création d’une classe, JAVA ajoute par défaut un constructeur par défaut. Vous
pouvez y ajouter de nouveaux constructeurs. Toutefois, l’ajout d’un nouveau constructeur,
annule automatiquement le constructeur par défaut.

Il est possible d’appeler un constructeur dans un autre en utilisant l’instruction
this(……..). Cette instruction doit être la première dans ce constructeur
On appelle :
 Constructeur par défaut : un constructeur qui ne prend aucun paramètre en
argument
 Constructeur de recopie : un constructeur qui prend en paramètre un élément
de même type que celui de la classe
III Accesseurs et mutateurs

Le principe d’encapsulation demande à masquer les détails d’implémentation d’une
classe. Pour les attributs, le principe de base voudrait qu’ils soient privés avec pour
conséquence immédiate, le fait de ne pouvoir accéder ou modifier la valeur des attributs. Pour
permettre l’accès ou la modification de la valeur des attributs, on ajoute pour chaque attribut :
 Un accesseur : c’est une méthode qui permet d’obtenir la valeur de l’attribut.
La syntaxe de cette méthode est getXXXX() pour les attributs non booléens et
isXXXX() pour les attributs booléens
 Un mutateur : qui permet de modifier la valeur de l’attribut. La syntaxe est
setXXXXX(typeChamp newValue). Le mutateur peut à titre d’exemple
contrôler la valeur avant d’affecter, assurant ainsi la cohérence interne de la
classe.
IV Application
Considérons un point en dimension 2. Chaque point est caractérisé par son abscisse et
son ordonné.
class Point{
// abscisse et ordonnée entières, privées:
private int x,y;
// accesseurs et mutateurs publics (voir la note ci-dessous pour le ‘‘final’’):
public final int getX(){return x;}
public final int getYy(){return y;}
public final void setX(int x){this.x=x;}
public final void setY(int y){this.y=y;}
// constructeurs (this désigne un autre constructeur):
point(int x, int y){setX(x); setY(y);}
point(){this(0,0);} // constructeur par défaut
point(point p){this(p.getX(),p.getY())} // constructeur de copie
}
Les champs c et les méthodes f d’un objet M sont identifiés par l’expression M.c et
M.f(…). Dans l’exemple précédent, si l’on a une instance p de la classe point, on peut écrire :
int a,b;
a = p.getX();
b = p.getY();
La syntaxe de création d’une instance est :

Point o = new Point(); // l’origine
Point p = new Point(3,4); // un nouveau point p
Point q = new Point(p); // une copie q de p

Exercice : Classe complexe, Fraction, Carre, Rectangle, Cercle.
NB :
Par convention :
 Le nom d’une propriété ou d’une méthode doit commencer par une minuscule ;
 Le nom d’une classe commence par une majuscule.
V Attributs final et static

La présen/ce de l’attribut final signifie:
 Pour un champ : que celui-ci est constant et tenter une modification engendre une
erreur de compilation ;
 Pour une méthode : qu’elle ne pourra pas être redéfinie dans une classe héritière ;
 Pour une classes : qu’elle ne pourra pas avoir d’héritière.
final int x = 1; // constante entière
x = 2; // erreur àla compilation
La présence de l’attribut static signifie:
 Pour un champ : que celui-ci ne dépend pas d’une instance de la classe et peut
être, par là même, stocké en un seul exemplaire ; toutes les instances peuvent y
faire référence et on peut même y faire référence en dehors de toute instance
 Pour une méthode : qu’elle ne fait appel qu’à des champs statiques et peut ainsi
être invoquée en dehors de toute instance.
Voici un exemple d’utilisation :
class Votant{
private static int nombre_votants;
static int getNombreVotants(){return nombre_votants;}
boolean a_vote = false;
static void vote(){if(!a_vote){nombre_votants++;} a_vote = true;}
}
...
votant A;
votant B;
votant.getNombreVotants() // 0
A.vote();
B.vote();
votant.getNombreVotants() // 2
VI Conversion des objets en chaîne de caractères

Le mécanisme de l’héritage permet de définir d’une manière très simple la façon dont les
objets vont être affichés. Il suffit de redéfinir une méthode
public String toString() dans la classe.
Par exemple, pour la classe point vue plus haut, il suffit de rajouter la ligne :
class point{
...
// convertisseur en chaîne de caractères:
public String toString(){return ("(" + x + "," + y + ")");}
...

}
VII Destructeurs
Le destructeur est une méthode particulière permettant de libérer la zone mémoire
utilisé par l’objet une fois que celle-ci n’est plus référencée. En C++ le destructeur doit être
défini de manière explicite. La définition du destructeur est très généralement necessaire pour
les éléments définies avec un new.
Sous Java l’opération est assuré par le ramasse miettes. Il est lancé automatiquement (il
n’est pas nécessaire de l’invoquer dans votre programme, sauf situations exceptionnelles) par
la méthode baptisée System.gc(). Chaque objet devenu inutile car plus référencé invoque alors
son destructeur appelé finalize() qui va provoquer son élimination de la mémoire. Cette
méthode n’a pas à être définie explicitement (car elle est héritée d’Object, que nous verrons
lors de l’héritage) mais peut, si nécessaire, être redéfinie pour effectuer une opération de
nettoyage (effacement de fichiers temporaires par exemple) avant que l’objet soit
définitivement détruit. L’exemple suivant contient pourra être relu après avoir lu les sections
sur l’héritage et les exceptions.
VIII Paquetages
Certaines applications manipulent un nombre assez élevé de classe au point où le
programmeur arrive à s’arracher les cheveux. Pour mettre de l’ordre dans cette montagne de
composants (classes) les classes sont organisé par groupe de même logique dans un espace de
nom correspondant à un package en Java.
Les packages permettent en outre de résoudre les conflits de nom de classe.
Lors de la création d’une classe, un paquetage est défini en mettant la commande
package, suivi du nom du package. Celui-ci est composé d’une succession de noms de
répertoires séparés par un point.
package mypackage;
public class MyClass {
// . . .
}
Maintenant, si quelqu'un veut utiliser MyClass ou, aussi bien, une des autres classes public
de mypackage, il doit utiliser le mot-clé import pour avoir à sa disposition le ou les noms définis
dans mypackage. L'autre solution est de donner le nom complet. Soit:
mypackage.MyClass m = new mypackage.MyClass();
ou
import mypackage.*;
// . . .
MyClass m = new MyClass();
Java dispose d’un nombre de classe dont java.lang, javax.swing…. Les classes du package
java.lang sont importés par défaut dans toute classe java.
IX Classes internes
Une classe peut être définie à l’intérieur d’une autre classe. Elle est alors dite interne.
Cette classe connaît tous les attributs de la classe dans laquelle elle est définie (y compris les
privés). Si la classe interne est déclarée private, par exemple, sa définition n’est, en revanche,
pas visible par les autres classes du paquetage.
public class Parcel {

class Destination {
private String label;
Destination(String whereTo) { label = whereTo;}
String readLabel() { return label; }

}
// L'utilisation d'une classe interne ressemble à l'utilisation de n'importe quelle autre
classe depuis Parcel :
public void ship(String dest) {
Destination d = new Destination(dest);
System.out.println(d.readLabel());
}
public static void main(String[] args) {
Parcel p = new Parcel() ;
p.ship("Tanzania");
}
}

CHAPITRE 2 Héritage, classes abstraites et interfaces
I Héritage
I.1 Introduction
L’héritage est le mécanisme central de la programmation orientée objet. Il permet de
d’enrichir une classe C en une classe C′en ne redéfinissant que les attributs spécifiques à C′ou en
redéfinissant dans la définition de C′, des méthodes déjà définies dans C. Comme on pouvait
faire référence à l’objet courant ou à ses constructeurs avec le mot-clé this, on peut faire
référence à la classe mère ou à ses constructeurs avec le mot-clé super.
Notons que les constructeurs ne s’héritent pas et que les classes héritières peuvent
diminuer l’encapsulation mais pas l’augmenter.
Pour indiquer qu’une A hérite d’une classe B, on utilise le bout de code :
class A extends B{
//Définition et implémentation de la classe.
A titre d’exemple, supposons qu’un pixel soit un point disposant d’une couleur. Il suffit
alors d’ajouter aux propriétés d’un point une nouvelle propriété appelé couleur. Ceci se fait
assez simplement par héritage de la manière suivante.
class Pixel extends Point{

// données:
protected int c;
// accesseurs / mutateurs:
public final int get_c(int c){return c;}
public final void set_c(int c){this.c=c;}
// constructeurs:
public Pixel(point A, int c){super(A.x,A.y); set_c(c);}
public Pixel(int a, int b, int c){super(a,b); set_c(c);}
public String toString(){return super.toString() + ", couleur=" + c;}
}
I.2 La classe Object

En Java, toutes les classes dérivent d’une classe appelée Object. Lorsque l’on définit une
nouvelle classe, celle-ci bénéficie des propriétés d’Object bien qu’on n’y fasse pas explicitement
référence (on écrit pas extends Object, par exemple), en général. Chaque classe est
représentée par une instance de la classe Class.
Voici les méthodes définies dans Object :
1) public boolean equals(Object x) désigne l’égalité par référence et équivaut, de ce
fait, l’opérateur ==. Elle est destinée àêtre redéfinie pour que la sémantique de
l’égalité soit conforme à ce qu’on veut. Par exemple, le equals() de la classe String
teste l’égalité caractère par caractère.

2) protected Object clone() permet de créer des copies de l’objet courant dans
certaines conditions (sur lesquelles nous reviendrons).
3) public final Class getClass() renvoie la classe exacte de l’objet courant (celle du
constructeur ayant servi à créer l’objet, même si celui a été casté). Cette méthode
étant final, elle nepeut pas être redéfinie.
4) public void finalize() est le destructeur qui nettoie la mémoire de l’objet courant
lors de l’appel par le ramasse-miette.
5) public String toString() renvoie une chaîne de caractères représentant l’objet
courant par le nom de la classe suivie du caractère @, suivie de son hashCode().
Cette méthode peut être redéfinie pour que la sémantique de représentation soit
conforme à ce qu’on veut, comme nous l’avons fait pour la classe point, par
exemple. La méthode public String toString() est appelée par
System.out.println().
En Java, l’héritage des classes est simple, ce qui signifie qu’une classe peut avoir plusieurs
descendantes mais une seule ascendante (sauf Object qui n’en a pas). Java propose, de
surcroît, une notion d’héritage multiple des interfaces.
II Méthodes et classes abstraites

Une classe abstraite est une classe qui possède au moins une méthode abstraite ou dont
on ne peut créer une instance. C’est le cas généralement lorsque dans une classe C, on souhaite
ou on est obligé de laisser la définition d’une méthode f aux héritières de la classe C.
Pour ce faire, on préfixe la méthode f du mot clé abstract. Lorsqu’une classe C dispose
d’une méthode abstraite ou hérite d’une classe disposant d’une méthode abstraite non encore
définie, celle-ci doit être déclarée abstraite et préfixée du mot clé abstract.
// Super classe abstraite
abstract class EquationGénéral
{
public abstract void résolution();
public void affichage()
{
System.out.print("Equation polynomiale: ");
}
}
// Classe Equation du second degré dérivée

class EquationDegré2 extends EquationGénéral
{
private double a, b, c, racine1, racine2;
public EquationDegré2(double a, double b, double c)

{
...
}
//on réalise la méthode abstraite du parent
public void résolution()
{
...
}
public void affichage()

{
super.affichage();
System.out.println("Equation quadratique");
...
}
}
III Interfaces
Une interface est une classe abstraite pure (qui ne possède que des méthodes
abstraites). Elle permet en Java de contourner l’absence d’héritage multiple. Tout champ d’une
interface est supposée public final et toutes ses méthodes sont supposées public abstract. On
définit une interface I en déclarant interface I comme on l’aurait fait pour une classe.
La définition est alors de la forme :
public interface I public interface I
{ {
public abstract void methode1(); void methode1 ();
public abstract void methode2(); void methode1 ();
} }
Une classe implémente une interface en utilisant le mot clé implements. Elle est utilisée
pour indiquer que la nouvelle classe satisfait aux conditions de l’interface. On obtient alors
class A implements I
{
// Redéfinition de methode1();
}
Application : Figure2D, Rectangle, Carré, Losange.
IV Héritage multiple d’interface

Il est possible d’avoir un héritage multiple d’interfaces. On obtient alors
public interface I1
{
void methode1();
}
public interface I2
{
void methode2();
}
class A implements I1, I2

{
// Redéfinition de methode1 ();
}
On remarque que la classe qui implémente l’interface doit redéfinir toutes les méthodes
des interfaces.

CHAPITRE 3 COLLECTION ET GESTION DES EXCEPTIONS
I Les collections d’objets

Lorsqu’on souhaite regrouper différentes valeurs au sein d’un même agrégat, plusieurs
choix sont possibles. Les tableaux sont, bien entendu, les plus fréquemment utilisés (Sauf
qu’on est obligé de connaitre le nombre d’éléments) mais Java propose, en standard, un
certain nombre de collections ayant chacune des propriétés adaptées à telle ou telle situation.
- Collection
- Set
- HashSet
- SortedSet
- TreeSet
- List
- ArrayList
- LinkedList
- Vector
- Map
- HashMap
- SortedMap
- TreeMap
Les interfaces à utiliser par des objets qui gèrent des collections sont :
 Collection : interface qui est implémentée par la plupart des objets qui gèrent des
collections

 Map : interface qui définit des méthodes pour des objets qui gèrent des collections sous
la forme clé/valeur
 Set : interface pour des objets qui n'autorisent pas de doublons dans l'ensemble
 List : interface pour des objets qui autorisent des doublons et un accès direct à un
élément
 SortedSet : interface qui étend l'interface Set et permet d'ordonner l'ensemble
 SortedMap : interface qui étend l'interface Map et permet d'ordonner l'ensemble
 Queue et Deque : collection qui stocke des éléments dans un certain ordre avant d'être
consommés pour être traités
Les principales classes de gestion de collection sont :
 La classe ArrayList
 La classe LinkedList
 La classe HashTable
I.1 La classe ArrayList

Elle permet de représenter un ensemble de valeurs dans lequel un élément peut revenir
plusieurs fois.
Les principales méthodes sont :
void add(int index, Object element) Ajouter l’objet en position index
int indexOf(Object o)
int lastIndexOf(Object o)
ListIterator listIterator()
ListIterator listIterator(int index)
Object remove(int index)
Object set(int index, Object element)
List subList(int fromIndex, int toIndex)
void add(Object element)
Object get(int index)
int size()
Ex:
ArrayList listeComplexe = new ArrayList();
//Ajout des éléments
listeComplexe.add(new Complexe(3,9));
listeComplexe.add(new Complexe(9));
//nombre de valeurs dans la liste
int nombreComplexe = listeComplexe.size();
//Parcours de la liste
Complexe leComplexe ;
for (int i = 0; i < nombreComplexe; i++) {
leComplexe = (Complexe) listeComplexe.get(i);
System.out.println("Attrapé le complexe " +leComplexe) ;
}
Il est possible de créer des collections d’objets typés. Ceci est possible pour la majorité
des classes gérant les collections. En typant une collection, cela permet de se passer de
l’opération de cast lors de la récupération
Exemple :
Déclarons et construisons une liste de tableau qui contient des objets Complexe :

ArrayList<Complexe> liste = new ArrayList<Complexe>();
listeComplexe.add(new Complexe(3,9));
listeComplexe.add(new Complexe(9));
for (int i = 0; i < nombreComplexe; i++) {
leComplexe = liste.get(i); //Plus besoin de cast.
System.out.println("Attrapé le complexe " +leComplexe) ;
}
I.2 La classe HashTable

Elle permet de représenter un ensemble de valeurs dans lequel un élément ne peut
revenir plusieurs fois à travers une table de hachage.
Les principales méthodes de cette classe sont :
void put(Object key, Object element)

Object get(Object o)
boolean containtKey(Object o)
Enumerator keys()
Object remove(Object key)
int size()
Exemple :
import java.util.*;
class test9 {
public static void main (String args[]) {
Hashtable h = new Hashtable();
Vector v = new Vector();
v.add("chaine 1");
v.add("chaine 2");
v.add("chaine 3");
h.put("jour", new Date());
h.put(new Integer(1),"premier");
h.put(new Integer(2),"deuxième");
System.out.println("Contenu du vector");
for (Enumeration e = v.elements() ; e.hasMoreElements() ; ) {
System.out.println(e.nextElement());
}
System.out.println("\nContenu de la hashtable");
for (Enumeration e = h.keys() ; e.hasMoreElements() ; ) {

System.out.println(e.nextElement());
}
I.3 La classe Vector

La classe Vector du package java.util permet de stocker des objets dans un tableau dont
la taille évolue avec les besoins.
Parmi les constructeurs disponibles, l'un n'attend aucun paramètre, l'autre attend une
taille initiale en paramètre. On construira donc un objet vect de la classe Vector en écrivant
simplement: Vector () ou Vector(n) pour prévoir une capacité initiale de n.

Les méthodes sont :
 addElement(Object elt) : On ajoute un objet à la fin du Vector ;

 elementAt(int n) :Element en position n. Premier à 0 ;
 contains(Object) : indique si l'objet est contenu dans le Vector.
 copyInto(Object[]) : copie les éléments dans un tableau classique.
 firstElement() : renvoie le premier élément.
 indexOf(Object) : renvoie l'indice de l'objet
 insertElementAt(Object, int) : insère l'objet à l'indice indiqué
 isEmpty() : indique si le Vector est vide
 lastElement() : renvoie le dernier élément
 removeAllElements() : vide le Vector
 removeElementAt(int) : retire l'objet dont l'indice est donné
 setElementAt(Object, int) : place l'objet à l'indice donné
 size() : renvoie le nombre d'éléments
II Les Exceptions
Dans un programme, il faut soigner la gestion des erreurs. Ce n’est pas toujours facile
avec les langages classiques. Java propose une approche très différente des approches
traditionnelles, à travers le mécanisme des exceptions. Une exception est une sorte de signal
indiquant qu’une erreur ou une situation anormale a eu lieu. On dit qu’une méthode ayant
détecté une situation anormale déclenche (throws) une exception. Cette exception pourra être
capturée (catch) par le code.
On peut distinguer deux types de situations anormales : les exceptions et les erreurs. Les
erreurs sont en principe des erreurs fatales et le programme s’arrête à la suite de ce type de
situation (classe java.lang.Error). Les exceptions ne sont pas uniquement des erreurs système.
Le programmeur peut définir des erreurs (non fatales) pour assurer que son programme est
robuste (classe java.lang.Exception).
Lorsqu’une méthode déclenche une exception la JVM remonte la suite des invocations
des méthodes jusqu’à atteindre une méthode qui capture cette exception. Si une telle
méthode n’est pas rencontrée, l’exécution est arrêtée.
L’utilisation des exceptions permet de :
 séparer le code correspondant au fonctionnement normal d’un programme, du code
concernant la gestion des erreurs,
 propager de proche en proche les exceptions d’une méthode à la méthode
appelante jusqu’à atteindre une méthode capable de gérer l’exception. Il n’est donc
pas nécessaire que la gestion d’une exception figure dans la méthode qui est
susceptible de déclencher cette exception. Une méthode peut ignorer la gestion
d’une exception à condition qu’elle transmette l’exception à la méthode appelante,
 regrouper par types la gestion des exceptions.
II.1 Définition
C’est un objet de la classe java.lang.Throwable qui est la classe mère de toutes les erreurs
et exceptions du langage Java. Seuls les objets qui sont des instances de cette classe (ou d’une
classe dérivée) sont déclenchés par la JVM et apparaissent comme arguments d’une clause
catch. Nous allons voir ci-après les sous-classes principales de la classe java.lang.Throwable.
 java.lang.Error est la classe des erreurs, qui indiquent un problème grave qui doit
conduire à l’arrêt de l’application en cours. Elle n’est pas susceptible d’être capturée. Un

certain nombre d’erreurs dérivent de cette classe, par exemple OutOfMemoryError, et
d’autres...
 java.lang.Exception est la classe des exceptions qui indiquent qu’une application devrait
raisonnablement les capturer, c’est-à-dire traiter ces cas de situations anormales, sans
arrêter le programme. Voici des exceptions classiquesqui dérivent de cette classe :
java.io.IOException, FileNotFoundException, et bien d’autres... A chaque objet de la
classe java.lang.Exception (ou d’uneclasse dérivée) est associé un message que l’on
peut récupérer avec la méthode getMessage() de la classe java.lang.Throwable
 RuntimeException est une classe dérivée de la précédente, et c’est la classe mère des
exceptions qui peuvent être déclenchées au cours de l’exécution d’un programme.
Supposons qu’une méthode soit susceptible de lever une exception de type
RuntimeException, il n’est pas obligatoire de le signaler dans sa clause throws. En effet,
les exceptions de type RuntimeException peuvent être levées mais ne pas être
capturées, générant ainsi un arrêt du programme. Voici quelques exemples de sous-
classes de la classe RuntimeException :
 ArrayStoreException,
 ArithmeticException,
 NullPointerException,
 NumberFormatException...
II.2 Capturer une exception

On l’a dit précédemment, lorsqu’une exception est lancée, elle se propage dans la pile
des méthodes jusqu’à être capturée. Si elle ne l’est pas, elle provoque la fin du programme, et
la pile des méthodes traversées est indiquée à l’utilisateur. La capture d’une exception se fait à
travers le bout de code
try{
// bloc de code
} catch( XyException e){

//traiter l’erreur
}finaly{
// a executer dans tous les cas
}
Supposons qu’une instruction instr d’une méthode uneMéthode lance une exception,
alors :
 si instr se trouve dans un bloc try, suivi d’un bloc catch alors,
1. les instructions du bloc try suivant instr ne sont pas exécutées,
2. les instructions du bloc catch sont exécutées,
3. le programme reprend son cours normalement avec l’instruction suivant le bloc
catch.
 si instr ne se trouve pas dans un bloc try comme décrit précédemment, alors la méthode
uneMethode est terminée. Si uneMethode est la méthode main, le programme se
termine, et l’exception n’a pas été capturée. Sinon, on se retrouve dans une méthode
qui a appelé la méthode uneMethode via une instruction instr2 qui lance à son tour
l’exception.
Quelque soit la situation, le bloc finaly sera exécuté. Ce bloc est généralement utilisé pour
fermer les fichiers ainsi que les connexions dans le cas des BD.

Une méthode susceptible de lancer une exception sans la capturer doit l’indiquer dans
son entête avec la clause throws. Cependant, comme précisé précédemment, on est dispensé
de déclarer le lancement des erreurs les plus courantes, comme par exemple :
 ArrayOutOfBoundsException,
 ArrayStoreException,
 ArithmeticException,
 NullPointerException,
 NumberFormatException...
Exemple :
class AttrapExcep{
static int moyenne(String[] liste) {
int somme=0, entier, nbNotes=0;
for (int i=0;i<liste.length;i++) {
try{
entier=Integer.parseInt(liste[i]);
somme+=entier;
nbNotes++;
}catch(NumberFormatException e) {
System.out.println("La "+(i+1)+"ième note pas entière");
}
}
return somme/nbNotes;
}
public static void main(String [] arg) {
System.out.println("La moyenne est :"+moyenne(arg));
}
Question : Que fournit le programme si on tape AttrapExcep 5 b 10
II.3 Définir de nouveaux types d’exceptions

Les exceptions sont des objets d’une classe dérivée de java.lang.Exception. Si l’on veut
signaler un événement inattendu, non prévu par l’API de Java, il faut dériver la classe Exception
et définir une nouvelle classe qui ne contient en général pas d’autre champ qu’un ou plusieurs
constructeur(s) et éventuellement une redéfinition de la méthode toString. Lors du lancement
d’une telle exception, on crée une instance de cette nouvelle classe.
Exemple :
class ExceptionRien extends Exception {
public String toString() {
return("Aucune note n’est valide’\n");
}
}
 Une exception de la classe X peut être lancée via : throw new X();
 Pour indique qu’une méthode « maMetode » génère une erreur de la classe XException
qui sera gérée par les méthodes appelantes, celle-ci doit avoir une entête de la forme :
typeRetour maMetode (listeArguments) throws XException

CHAPITRE 4 LA PERSISTENCE
I Persistance via des fichiers

La lecture et l’écriture dans les fichiers se font à travers les classes FileInputStream
(FileReader) et et FileOutputStream (FileWriter)
On instancie un objet de la classe FileInputStream(flux d’entrée) ou
FileOutputStream(flux de sortie) avec un nom ou avec un objet de la classe File, mais attention
il s’agit de fichiers binaires.
Plus généralement :
 Si on désire écrire des entiers ou tout autre type primitif, dans le fichier, il ouvrira un flux
de type « DataOutputStream» comme suit :
FileOutputStream fos=new FileOutputStream("nomdufichier");
DataOutputStream dos= new DataOutputStream(fos);
dos.writeInt(15);
 Si on désire écrire des objets dans le fichier, il ouvrira un flux de sérialisation de type
« ObjectOutputStream» comme suit :
FileOutputStream fos=new FileOutputStream("nomdufichier");
ObjectOutputStream oos= ObjectOutputStream (fos);
oos.writeObject(new Point(10,20));
oos.writeObject("Bonjour”);
La lecture d’un fichier texte se fait très facilement via :
import java.io.*;
BufferedReader console = new BufferedReader(new FileReader("toto.txt"));
String ligne = null;
try{
while((ligne = in.readLine()) != null){
System.out.println(ligne);
}catch(IOException){ // Pas d’erreur en théorie...
} finaly{
L’écriture dans un fichier texte se fait via :
in.close();
} import java.io.*;
File f = new File("toto.txt");
PrintWriter out = new PrintWriter(new FileWriter(f));
try{
out.println("Coucou");
}catch(IOException){ // Pas d’erreur en théorie...
}finaly{ out.close();
L’écriture} dans un fichier à accès aléatoire se fait via :
try{
RandomAccessFile fichier = new RandomAccessFile("foo.txt","rw");
fichier.writeUTF("Coucou!");
}catch(Exception e){
System.out.println(e);
}

II L’API JDBC
JDBC est l'acronyme de Java DataBase Connectivity et désigne une API définie par Sun
pour permettre un accès aux bases de données avec Java et ceci de manière « indépendante de
la plate forme et du SGBD ».
Pour pouvoir utiliser JDBC, il faut un pilote qui est spécifique à la base de données à
laquelle on veut accéder. Avec le JDK, Oracle fournit un pilote qui permet l'accès aux bases de
données via ODBC.
II.1 Type de pilote JDBC

Il existe quatre types de pilotes JDBC :
1) Le pont JDBC−ODBC qui s'utilise avec ODBC et un pilote ODBC spécifique pour la base à
accéder. Cette solution fonctionne très bien sous Windows. C'est la solution idéale pour
des développements avec exécution sous Windows d'une application locale. Cette
solution « simple » pour le développement possède plusieurs inconvénients :
 la multiplication du nombre de couches rend complexe l'architecture (bien que
transparent pour le développeur) et détériore un peu les performances
 lors du déploiement, ODBC et son pilote doivent être installé sur tous les postes
ou l'application va fonctionner.
 la partie native (ODBC et son pilote) rend l'application moins portable et
dépendante d'une plateforme.
2) Type 2 : un driver écrit en java qui appelle l'API native de la base de données. Ce type de
driver convertit les ordres JDBC pour appeler directement les API de la base de données
via un pilote natif sur le client. Ce type de driver nécessite aussi l'utilisation de code natif
sur le client.
3) Type 3 : un driver écrit en Java utilisant le protocole natif de la base de données : Ce type
de driver utilise un protocole réseau propriétaire spécifique à une base de données. Un
serveur dédié reçoit les messages par ce protocole et dialogue directement avec la base
de données. Ce type de driver peut être facilement utilisé par une applet mais dans ce cas
le serveur intermédiaire doit obligatoirement être installé sur la machine contenant le
serveur web.
4) Type 4 : un driver Java natif : Ce type de driver, écrit en java, appelle directement le SGBD
par le réseau. Ils sont fournis par l'éditeur de la base de données.
Les drivers se présentent souvent sous forme de fichiers jar dont le chemin doit être
ajouté au classpath pour permettre au programme de l'utiliser.
II.2 Présentation des classes de l’API JDBC

Les classes principales de l’API JDBC sont décrites dans le tableau ci-dessous et sont
présente dans le package java.sql.
Classe Rôles
DriverManager charge et configure le driver de la base de données.
Connection réalise la Connection et l'authentification à la base de données.
Statement contient la requête SQL et la transmet à la base de données.

PreparedStatement Identique au Statement dans le cas des requêtes paramétrées
CallableStatement définit les méthodes pour un objet qui va permettre d'appeler une
procédure stockée.
DatabaseMetaData informations à propos de la base de données : nom des tables, index,
version ...
ResultSet résultat d'une requête et information sur une table. L'accès se fait
enregistrement par enregistrement.
ResultSetMetaData informations sur les colonnes (nom et type) d'un ResultSet
II.3 Etablir une connexion à une base de donnée

Pour établir une connexion à une base de données, il faut :
1) Charger le driver de la BD à travers le code : Class.forName(nomDriver)
Ex :
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); // pour JDBC-ODBC
Class.forName("com.mysql.jdbc.Driver"); //Pour MYSQL
Le nom du driver apparait dans la documentation du driver.
2) Créer une instance de la classe Connection à travers la classe DriverManager auquel
on passe une chaine sous forme d’url. Cette url permet de localiser les SGBD. Cela se
fait comme suit : Connection con = DriverManager.getConnection(DBurl);
Ex :
Connection con = DriverManager.getConnection("jdbc:odbc:testDB");
Connection c =DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","");
II.4 Executer des requêtes

Les requêtes sont exécutées avec les méthodes d'un objet Statement que l'on obtient à
partir d'un objet Connection.
Les requêtes d’interrogation sont exécutées à travers la méthode executeQuerry de
l’objet Statement.
Les requêtes de mise à jour etDDL sont exécutées à travers la méthode executeUpdate de
l’objet Statement. Lorsque la méthode executeUpdate() est utilisée pour exécuter un
traitement de type DDL ( Data Defiition Langage :définition de données ) comme la création
d'un table, elle retourne 0. Si la méthode retourne 0, cela peut signifier deux choses : le
traitement de mise à jour n'a affecté aucun enregistrement ou le traitement concernait un
traitement de type DDL.
ResultSet résultats = null;
String requete = "SELECT * FROM client";
try {
Statement stmt = con.createStatement(); //creation du statement
résultats = stmt.executeQuery(requete); //execution de la requite
//parcours du jeu d’enregistrement
while(résultats.next()){
System.out.println(résultats.getString("code_cli"));
}

Resultats.close() //Ferme le jeu de résultat
//insertion d'un enregistrement dans la table client
String requete = "INSERT INTO client VALUES (3,'client 3','prenom 3')";
int nbMaj = stmt.executeUpdate(requete);
System.out.println("nb mise a jour = "+nbMaj);
} catch (SQLException e) {
//traitement de l'exception
}
Pour avoir les informations sur les colonnes du ResultSet, on utilise la classe
ResultSetMetaData.
Ex : ResultSetMetaData rsmd;
rsmd = rs.getMetaData();
int nbCols = rsmd.getColumnCount();
for( int j=1;j<=nbCols;j++){
System.out.println(rsmd.getColumnName(j)) ;
}
II.5 Executer les requêtes précompilées

Ils permettent de gérer les requêtes paramétrées. Chaque paramètre est remplacé par
un ?.
Exemple
PreparedStatement recherchePersonne =
con.prepareStatement("SELECT * FROM personnes WHERE nom_personne = ?");
recherchePersonne.setString(1, "Abega");
ResultSet resultats = recherchePersonne.executeQuery();
III Les transactions

Une transaction est gérée à partir de l'objet Connection. Par défaut, une connection est
en mode auto-commit. Dans ce mode, chaque opération est validée unitairement pour former
la transaction.
Pour pouvoir rassembler plusieurs traitements dans une transaction, il faut tout d'abord
désactiver le mode auto-commit.
La classe Connection possède la méthode setAutoCommit() qui attend un booléen qui
précise le mode de fonctionnement. Exemple: connection.setAutoCommit(false);
Une fois le mode auto-commit désactivé, un appel à la méthode commit() de la classe
Connection permet de valider la transaction courante. L'appel à cette méthode valide la
transaction courante et créé implicitement une nouvelle transaction.
Si une anomalie intervient durant la transaction, il est possible de faire un retour en
arrière pour revenir à la situation de la base de données au début de la transaction en appelant
la méthode rollback() de la classe Connection.
IV Les procédures et fonction stockées

L'interface CallableStatement définit les méthodes pour un objet qui va permettre
d'appeler une procédure stockée. Cette interface hérite de l'interface PreparedStatement. Il
est créer en utilisant la méthode prepareCall() d'un objet de type Connection. Cette méthode
attend en paramètre une chaîne de caractères contenant la chaîne d'appel de la procédure
stockée.
L'appel d'une procédure étant particulier à chaque base de données supportant une telle
fonctionnalité, JDBC propose une syntaxe unifiée qui sera transcrite par le pilote en un appel
natif à la base de données. Cette syntaxe peut prendre plusieurs formes :
 {call nom_procedure_stockees}: cette forme la plus simple permet l'appel d'une
procédure stockée sansparamètre ni valeur de retour
 {call nom_procedure_stockees(?, ?, ...)}: cette forme permet l'appel d'une
procédure stockée avec des paramètres
 {? = call nom_procedure_stockees(?, ?, ...)}: cette forme permet l'appel d'une
procédure stockée avec des paramètre et une valeur de retour
Un ensemble de méthode setXXX() et getXXX (ou XXX représente un type primitif ou
certains objets tel que String, Date, Object, ...) permet de fournir les valeurs de chaque
paramètre d’entrée ou de récupérer les paramètres de sortie défini dans la requête. Le premier
paramètre de ces méthodes précise le numéro du paramètre dont la méthode va fournir la
valeur. Le second paramètre précise cette valeur.
Ce programme montre l’exemple de l’appel d’une procédure stockée.
public static int validerConsigneEmploye(String numOpe) throws Exception {
int n = 0;
CallableStatement Traiter = null;
try {
chaine = "{call terminerConsigneEmploye(?,?)}";
Traiter = con.prepareCall(chaine);
Traiter.registerOutParameter(2, Types.INTEGER); //definir un paramètrer de sortie
Traiter.setString(1, numOpe); //1
Traiter.execute();
n = Traiter.getInt(2);//récupération du résultat
System.out.println("result " + n);
}catch (SQLException ex) {
ex.printStackTrace();
throw new Exception(ex.getMessage());
}finally {
try { Traiter.close();} catch (Exception e) { e.printStackTrace(); }
}
return n;
}

CHAPITRE 5 LES INTERFACES GRAPHIQUES ET LES

EVENEMENTS (VOIR TP)
I Introduction
Il n’est pas question dans ce chapitre de faire un tour de la conception des interfaces
graphiques, mais de présenter les classes essentielles. L’essentiel des éléments de conceptions
des interfaces graphiques est contenue dans les package AWT (Abstract Windows Toolkit) et
SWING. Ces deux bibliothèques constitue la bibliothèque officielle JFC(Java Foundation
Classes).
AWT est une bibliothèque graphique originale et pratique, qui a beaucoup contribué au
succès de Java, mais elle a deux inconvénients : puisque ses composants sont censés exister
sur tous les environnements visés, leur nombre est forcément réduit ; d’autre part, même
réputés identiques, des composants appartenant à des systèmes différents présentent malgré
tout des différences de fonctionnement qui finissent par limiter la portabilité des programmes
qui les utilisent.
C’est la raison pour laquelle AWT a été complétée par une bibliothèque plus puissante,
permettant de coder en Pur Java les composants dépendant du système. Au final, Swing va
plus loin que AWT mais ne la remplace pas ; au contraire, les principes de base et un grand
nombre d’éléments de Swing sont ceux de AWT.
II Les classes de SWING

Les principales classes de SWING sont :
 Une fenêtre ou un cadre (frame) qui peut être créé en utilisant la classe JFrame.
 Une fenêtre modale qui peut être créé en utilisant la classe JDialog.
 Un panneau (panel) ou un carreau (pane) contenant tous les boutons, champs
textuels, libellés et autres composants. Les panneaux sont créés à l'aide de la classe
JPanel.
 Les contrôles graphiques tels que les boutons (JButton), les champs textuels
(JTextField), les listes (JList)...
Outre ces classes, citons aussi :
Swing dispose d’autre part les classes suivantes :
JButton JScrollPane JEditorPane JTabbedPane
ButtonGroup JSpinner JScrollBar JTable
JLabel JTextField JSlider JToolTip
JCheckBox JTextArea JProgressBar JTree
JRadioButton JPasswordField JComboBox JViewPort
JToggleButton JFormattedTextField JList ImageIcon
Les différents composants sont positionnés sur leurs conteneurs à travers les
gestionnaires de disposition (Layout Manager). Les gestionnaires de disposition assurent que
l'écran aura une bonne tête quelles que soient les dimensions de la fenêtre.
Swing propose les gestionnaires de disposition suivants :
 FlowLayout (présentation en file)

 GridLayout (présentation en grille)
 BoxLayout (présentation en lignes ou colonnes)
 BorderLayout (présentation avec bordures)
 CardLayout (présentation en pile)
 GridBagLayout (présentation en grille composite)
 SpringLayout (présentation avec ressorts)
Tu peux aussi créer des menus (JMenu et JPopupMenu), des fenêtres à la demande
(popup), des cadres imbriqués dans d'autres cadres (JInternalFrame) et utiliser les fenêtres
standard de manipulation d'informations : JFileChooser (choix de fichier), JColorChooser
(choix de couleur) et JOptionPane (choix d'option).
III Les boites de dialogues

Elles peuvent être utilisées via un des appels ci-dessous :
 JOptionPane.showMessageDialog()
 JOptionPane.showConfirmDialog().
Une des utilisations possible et assez complexe est :
Object[] selections = {"First", "Second", "Third" };
Object val = JOptionPane.showInputDialog(null, "Choose one", "Input",
JOptionPane.INFORMATION_MESSAGE, null, selections, selections[0]);
if(val != null){
String t=val.toString();
JOptionPane.showMessageDialog(null, t ,"Hey!", JOptionPane.ERROR_MESSAGE);
}
IV Utilisation des icones

On peut créer une icone en utilisant la classe ImageIcon
static String path = "C:/aaa-TIJ2-distribution/code/c13/";
static Icon[] faces = { new ImageIcon(path + "face0.gif"),
new ImageIcon(path + "face1.gif"),
new ImageIcon(path + "face4.gif") };
JButton jb = new JButton("JButton", faces[3]), jb2 = new JButton("Disable");
Lorsque l’image est de grande taille, on utilise plutôt un code :
Toolkit.getDefaultToolkit().getImage("nomImage");
Exemple:
uneImage = Toolkit.getDefaultToolkit().getImage("images/XGorce.081102.gif");
setPreferredSize(new Dimension(500, 150));
V Utilisation des JTable

Pour afficher les informations dans un JTable, la méthod la plus indiquer consiste à définir
une classe étendant la classe abstraite AbstractTableModel et indiquant comment les
informations seront affichés. Cette interface définit les méthodes :

 getRowCount : le nombre de lignes du tableau n’est autre que le nombre de
membres du club ;
 getColumnCount : le nombre de colonnes du tableau dépend que des champs que
nous avons décidé de représenter
 getColumnName : donne le nom de chaque colonne, c’est-à-dire ce qu’il faut
afficher dans la première ligne ;
 getColumnClass : donne le type des informations de chaque colonne (supposée
homogène), cela permet d’en donner une présentation adaptée comme, pour un
booléen, une case à cocher ;
 getValueAt : cette méthode est la plus importante : getValueAt(i, j) renvoie
l’élément qui se trouve à la ligne i et la colonne j du tableau.
Une fois cette classe créer on peut utiliser le code :
Jtable j=new JTable(new Xmodel(…..)) ;
Ou
XModel xmodel=new XModel(…..);
JTable j=new JTable() ;
j.setModel(xmodel) ;
Pour notifier les modifications sur le modèle, on utilise modeleTable.fireTable…()
On peut aussi utiliser :

JTable j=new JTable(New DefaultTableModel(entete,ligne))
Où :
entete: est un tableau à une dimension précisant le nom des entêtes de colonnes
ligne: est un tableau à deux dimension contenant les lignes du tableau.
VI Les looks and Feel

Les looks and Feel permettent de définir l’apparence graphique des fenêtres au moment
de l’exécution. Le chargement d’un look and feel se fait à travers la classe UImanager comme le
montre l’exemple suivant :
try{
//ici le look and feel est celui du système
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch(Exception e) {}
On peut initialiser le look and feel à celui d’une classe chargé en utilisant le code
try{
//ici le look and feel est celui du système
UIManager.setLookAndFeel(“nom du look and feel “);
} catch(Exception e) {}

VII Les évènements
La gestion des évènements se fait à travers les Listener ou gestionnaires d’évènements. Il
existe différentes interfaces de gestion d’évènements que l’utilisateur doit pouvoir
implémenter.
VII.1 Les Interfaces de gestion d’évènements
ActionListener
Cette interface concerne des actions (avec la souris ou le clavier) sur un composant qui
les traduit en une commande de plus haut niveau, comme un choix dans une liste ou un menu,
une pression sur un bouton,
etc. L’interface se compose d’une seule méthode :
void actionPerformed(ActionEvent e) Appelée lorsqu’une action a été faite (ce que
action veut dire dépend du composant : presser un bouton, cocher ou décocher une case à
cocher, faire un choix dans un menu, etc.). On peut utiliser e.getActionCommand() pour
identifier l’action en question.
FocusListener
Les événements qui nous intéressent ici concernent l’acquisition ou la perte du focus par
un composant. Les méthodes de cette interface sont :
void focusGained(FocusEvent e) Appelée lorsque le composant en question acquiert le
focus (c’est-à-dire que les actions sur le clavier lui seront désormais adressées).
void focusLost(FocusEvent e) Appelée lorsque le composant perd le focus (un autre
composant l’a pris).
KeyListener
Il se produit un événement clavier chaque fois qu’une touche est pressée ou relâchée.
Tous les composants peuvent être sources de tels événements, il suffit qu’ils aient le focus.
Cette interface se compose de trois méthodes :
void keyPressed(KeyEvent e) Appelée lorsqu’une touche a été pressée.
void keyReleased(KeyEvent e) Appelée lorsqu’une touche a été relâchée.
void keyTyped(KeyEvent e) Appelée lorsqu’un caractère a été saisi au clavier.
Les événements keyPressed et keyReleased sont de bas niveau. Chacun correspond à une
touche unique, et fournit un code numérique (le code de touche virtuelle, ou VK code). En
particulier, keyPressed est le seul moyen de détecter la pression d’une touche ne produisant
pas de caractère (comme «Shift», «Ctrl »,etc.).
L’événement keyTyped, au contraire, est assez élaboré, puisqu’il est capable d’agréger
plusieurs touches pressées ensemble pour former un unique caractère : A majuscule, Control-C,
etc.
MouseListener
L’interface MouseListener concerne les événements isolés générés à l’aide de la souris.
Les méthodes de cette interface sont :

void mousePressed(MouseEvent e) Appelée lorsqu’un bouton de la souris a été pressé, le
pointeur se trouvant sur le composant.
void mouseReleased(MouseEvent e) Appelée lorsqu’un bouton de la souris a été relâché,
alors qu’il avait été pressé quand le pointeur se trouvait sur le composant .
void mouseClicked(MouseEvent e) Appelée lorsque la souris a été cliquée (pressée puis
relâchée au même endroit ), le curseur se trouvant sur le composant.
void mouseEntered(MouseEvent e) Appelée lorsque le pointeur de la souris commence à
à survoler le composant dont on guette les événements.
void mouseExited(MouseEvent e) Appelée lorsque le pointeur de la souris cesse de
survoler le composant dont on guette les événements.
Autres interfaces
Les autres interfaces sont
MouseMotionListener : Cette interface concerne les mouvements de la souris.
WindowListener : Les événements que cette interface concerne sont les actions sur une
fenêtre : ouverture et fermeture et, dans le cas d’un cadre ou d’un dialogue, les actions sur les
éléments de la barre de titre. Ce qui donne les méthodes :
Consulter la documentation pour plus amples informations
VII.2 Intercepter un évènement

Une des méthode permettant d’intercepter un évènement (e) sur un objet (b) consiste à
ajouter à cet objet un Listener(X prenant en charge l’évènement e). Ce listener devra
implémenter toutes les méthodes de l’interface.
Le code est alors b.addXListener(X) ;
On appelle XAdapter une classe implémentant XListener et dont le code est vide pour
chaque méthode. On peut utiliser cette classe pour simplifier les méthodes que l’on souhaite
prendre en charge. On peut par exemple procéder comme suit :
JButton jButton=new JButton();
jButton.addMouseListener(new MouseAdapter(){
public void mouseClicked(MouseEvent e) {
JOptionPane.showMessageDialog(null,"Bonjour");
}
});
Vous remarquerez que les méthodes que les autres méthodes de l’interface
MouseListener n’ont été implémenté.

ANNEXE I : UTILISER JAVA EN LIGNE DE COMMANDE

Pour pouvoir développer sous JAVA, il est important de disposer sur son poste le logiciel
J2SDK( JAVA To Software Development Kit) encore abrégé JDK. Ce logiciel intègre les outils de
développement dont le compilateur java et la machine virtuelle JAVA encore appelée JRE(JAVA
Runtime Environment). Ce logiciel peut être télécharger depuis le site Web de oracle.
Une fois le logiciel télécharger et installé, il reste de définir deux variables
d’environnement. Pour cela, suit les étapes suivantes :
Etape 1 :
Dans Windows, par exemple, clique sur le bouton démarrer et ouvre le Panneau de
configuration (il peut être caché derrière le menu Paramètres), puis double-clique sur l’icône
Système. Sélectionne l’onglet Avancé et clique sur le bouton Variables d’environnement. . Tu
obtiens alors la fenêtre suivante :
Etape 2 : Définir la variable Path

Dans la zone système, Clique sur le bouton Nouveau en bas de la fenêtre et déclare la
variable Path qui permettra à Windows (ou Unix) de trouver J2SDK sur ta machine. Vérifie bien
le nom du répertoire où tu as installé Java. Si la variable Path existe déjà, clique sur le bouton
Modifier et ajoute le nom complet du répertoire Java suivi d’un point-virgule au tout début de
la boîte Valeur de la variable : Soit comme suit :
CHAHIE THOMAS PAULIN a

Etape 3 : Définir la variable CLASSPATH

Déclare la variable CLASSPATH en entrant comme valeur un point suivi d’un point-
virgule. Cette variable système permettra à Java de trouver tes programmes. Le point signifie
que Java doit chercher tes programmes à partir du répertoire courant. Le point-virgule n’est
qu’un séparateur :
A la fin de ces étapes, l’installation et la configuration est terminée.
CHAHIE THOMAS PAULIN b

ANNXE II : ETUDE DE QUELQUES CLASSES JAVA

VIII LA CLASSE STRING
Dans beaucoup de cas, les chaînes de caractères qu’on utilise ne sont pas destinées à
être modifiées, il s’agit d’objets constants. Le compilateur Java transforme automatiquement
les constantes de type chaînes en objets de type String. On peut aussi créer explicitement un
objet de type String avec un des constructeurs de la classe.
En plus de ses constructeurs (il y en a plusieurs), la classe fournit des méthodes de
comparaisons, de recherches, d’extractions et de copies. Voici quelques-unes des plus utilisées.
Vous pouvez consultez la documentation pour plus d’informations.
Prototype Rôle
public String() Constructeur
public String(String str) Constructeur
public int length() longueur de la chaîne
public char charAt(int index) caractère à la position index
public String substring(int dbt,int fin) extrait la chaîne entre les positions dbt et fin
public boolean equals(Object o) test d’ égalité
public boolean startsWith(String pref) test si le début de la chaîne est égal à pref
public boolean endsWith(String suf) test si la fin de la chaîne est égal à suf
public int compareTo(String str) comparaison des 2 chaînes,(0 si str est égale,
négatif si elle est inférieure, positif sinon)
public int indexOf(int ch) position du caractère ch
public int lastIndexOf(int ch) dernière position du caractère ch
public int indexOf(int ch, int i) position de ch à partir de i
public int indexOf(String str) position de la ss-chaîne str
public String replace(char c,char d) remplace toute occurrence de c par d
public String toLowerCase() conversion en minuscules
public String toUpperCase() conversion en majuscules
public char[] toCharArray() conversion en tableau de caractères
public String trim() suppression des espace en début et fin
public static String valueOf(char t[]) conversion d’un tableau de caractères en String
Exemple :
class Chaines{
public static void main(String [] arg){
String a="Coucou";
String b=new String(", c’est moi !\n");
String c=a+b;
System.out.println(c);
System.out.println("longueur de a : "+a.length()); //6
System.out.println("caractere en position 2 : "+a.charAt(2)); //u
System.out.println("a est Coucou : "+a.equals("Coucou")); //true
System.out.println("a est b : "+a.equals(b)); //false
System.out.println("position de o dans a? "+a.indexOf(’o’)); //1
System.out.println("position du dernier o dans a? "+a.lastIndexOf(’o’)); //4
CHAHIE THOMAS PAULIN c

System.out.println("position de \"cou\" dans a? "+a.indexOf("cou")); //3
System.out.println("position de \"moi\" dans a? "+a.indexOf("moi")); //-1
System.out.println("a en majuscules : "+a.toUpperCase()); //COUCOU
System.out.println("a en minuscules : "+a.toLowerCase()); //coucou
System.out.println("a > b ? "+a.compareTo(b)); //23
System.out.println("a < b ? "+b.compareTo(a)); //-23
}
}
IX La classe java.lang.Math
C’est la bibliothèque mathématique de Java. Toutes ses méthodes sont publiques et
statiques. Voici quelques méthodes des plus utilisées.
public static final double E
public static final double PI
public static native double sin(double a)
public static native double cos(double a)
public static native double tan(double a)
public static native double asin(double a)
public static native double acos(double a)
public static native double atan(double a)
public static native double exp(double a)
public static native double log(double a)
public static native double sqrt(double a)
public static native double ceil(double a) // partie entiere sup
public static native double floor(double a) // partie entiere inf
public static native double pow(double a,double b) Throws: ArithmeticException
// a puissance b
public static int round(float a)
public static synchronized double random()
public static int abs(int a)
....... et les surcharges de abs .......
public static int max(int a,int b)
....... et les surcharges de max .......
public static int min(int a,int b)
....... et les surcharges de min .......
X La gestion des dates

La manipulation et l’affichage des dates sont traités en Java avec beaucoup de soin
(portabilité oblige !), mais la question peut sembler un peu embrouillée car elle est répartie sur
trois classes distinctes de manière un peu arbitraire :
 java.util.Date - Un objet de cette classe encapsule un instant dans le temps (représenté
par le nombre de millisecondes écoulées entre le 1er janvier 1970, à 0:00:00 heures
GMT, et cet instant).D’autre part, ces objets ont des méthodes pour le calcul de l’année,
du mois, du jour, etc., mais elles sont désapprouvées, ce travail doit désormais être
donné à faire aux objets Calendar.
 java.util.GregorianCalendar - Cette classe est une sous-classe de la classe abstraite
Calendar. Ses instances représentent des dates, décomposées en plusieurs nombres qui
CHAHIE THOMAS PAULIN d

expriment l’année, le mois, le jour dans le mois, dans l’année et dans la semaine, l’heure,
les minutes, etc.
 java.text.DateFormat - Les instances de cette classe, fortement dépendante des
particularités locales, s’occupent de l’expression textuelle des dates.
Exemple
import java.util.*;
import java.text.SimpleDateFormat;
public class MonFormatDate {
public static void main( String [] args ) {

// Crée un objet Date et l'affiche dans le format par défaut
Date maintenant = new Date();
System.out.println("Nous sommes le : " + SimpleDateFormat.getDateInstance().format(maintenant));
// Affiche la date comme ceci : 23-06-05
SimpleDateFormat formatDate = new SimpleDateFormat("dd-MM-yy");
String dateFormatée = formatDate.format(maintenant);
System.out.println("Nous sommes le (jj-MM-aa) : " + dateFormatée);
//une autre date à partir de l'objet Calendar
GregorianCalendar cal=new GregorianCalendar(2000,11,23,4,12);
maintenant=cal.getTime();
// Affiche la date comme ceci : 23/06/2005

formatDate = new SimpleDateFormat("dd/MM/yyyy");
dateFormatée = formatDate.format(maintenant);
System.out.println("Nous sommes le (jj/MM/aaaa) : " + dateFormatée);
// Affiche la date comme ceci : jeudi 23 juin 2005

formatDate = new SimpleDateFormat("EEEE d MMM yyyy");
XI Classes enveloppantes
dateFormatée des types primitifs
= formatDate.format(maintenant);
System.out.println("Nous sommes le (JJJJ
Les types primitifs disposent jj MMMM
de classes aaaa)enveloppante
dites : " + dateFormatée);
permettant de stocker
// Affiche l'heure comme ceci : 20h 30m 17s
certaines valeurs utiles, telles Float.NaN (not a number ) et Float.POSITIVE_INFINITY (définies
par formatDate
le standard=IEEE754)
new SimpleDateFormat("kk'h' mm'm' ss's'");
ou encore Long.MAX_VALUE (le plus grand entier long), ou de réaliser
dateFormatée = formatDate.format(maintenant);
certaines opérations comme, par exemple, Integer.parseInt(s) qui renvoie un entier issu de la
System.out.println("Il est (HHh MMm SSs) : "
chaîne de caractères s.
+ dateFormatée);
}
}
CHAHIE THOMAS PAULIN e

ANNEXE III : Lecture d'un texte d'une fenêtre console

On utiliser la classe Scanne( du package java.util.Scanner) pour lire comme le montre le
code suivant :
class Moyenne {
public static void main(String args[]){
Scanner keyb = new Scanner(System.in);
// Simplification: un seul cours par année
System.out.print("Note du semestre d’hiver: ");
double noteHiver = keyb.nextDouble();
System.out.print("Note du semestre d'été: ");
double noteEte = keyb.nextDouble();
if ((noteHiver >= 0) && (noteEte >= 0)) {
double moyenne = (noteHiver + noteEte) / 2;
System.out.print("Nom de l'étudiant: ");
String nom = keyb.next();
System.out.println("La moyenne de " + nom +" est de: " + moyenne);}
else {
System.out.println
("Erreur: les notes doivent être positives");
}
}
}
CHAHIE THOMAS PAULIN f

CHAHIE THOMAS PAULIN A

Langue

CoursCASA 2 GSI2 v2

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

CoursCASA 2 GSI2 v2

Titre original :

Transféré par

Droits d'auteur :

CONCEPTION ET ADAPTATION DES SOLUTIONS

CHAHIE THOMAS PAULIN i

CHAHIE THOMAS PAULIN ii

CHAPITRE 0 PRINCIPE DE LA PROGRAMMATION ORIENTEE

CHAHIE THOMAS PAULIN 1

III Encapsulation des données

CHAHIE THOMAS PAULIN 2

CHAHIE THOMAS PAULIN 3

VII Eléments de syntaxe du langage Java

VII.1 Types primitifs

Tableau 0-1: Tableau des types primitifs Java

CHAHIE THOMAS PAULIN 4

CHAHIE THOMAS PAULIN 5

int t21[][] = {{1, 2, 3}, {4, 5, 6}};

Toutes les lignes d’un tableau à 2 dimensions n’ont pas

VII.3 Les opérateurs Java

x <= y infériorité large (vrai si x<=y)

Tableau 2: Opérations de base du langage

VIII Les structures de contrôles

VIII.1 La structure if (Si)

VIII.2 Les choix multiples

CHAHIE THOMAS PAULIN 7

VIII.3 La structure for ( pour)

CHAHIE THOMAS PAULIN 8

VIII.5 La structure do..while (Repeter)

IX Les sous programmes

public static void main(String[] args) {

CHAHIE THOMAS PAULIN 9

CHAHIE THOMAS PAULIN 10

CHAPITRE 1 CLASSES / PAQUETAGES

CHAHIE THOMAS PAULIN 11

La syntaxe de création d’une instance est : //pour l’instant

CHAHIE THOMAS PAULIN 12

III Accesseurs et mutateurs

La syntaxe de création d’une instance est :

CHAHIE THOMAS PAULIN 13

Exercice : Classe complexe, Fraction, Carre, Rectangle, Cercle.

V Attributs final et static

VI Conversion des objets en chaîne de caractères

CHAHIE THOMAS PAULIN 14

CHAHIE THOMAS PAULIN 15

String readLabel() { return label; }

CHAHIE THOMAS PAULIN 16

CHAPITRE 2 Héritage, classes abstraites et interfaces

//Définition et implémentation de la classe.

class Pixel extends Point{

I.2 La classe Object

CHAHIE THOMAS PAULIN 17

II Méthodes et classes abstraites

// Classe Equation du second degré dérivée

public EquationDegré2(double a, double b, double c)

CHAHIE THOMAS PAULIN 18

IV Héritage multiple d’interface

class A implements I1, I2

CHAHIE THOMAS PAULIN 19

CHAPITRE 3 COLLECTION ET GESTION DES EXCEPTIONS

I Les collections d’objets

CHAHIE THOMAS PAULIN 20

I.1 La classe ArrayList

CHAHIE THOMAS PAULIN 21

I.2 La classe HashTable

void put(Object key, Object element)

for (Enumeration e = h.keys() ; e.hasMoreElements() ; ) {

I.3 La classe Vector