COURS DE PROGRAMMATION JAVA

Table des matières

COURS DE PROGRAMMATION JAVA ................................................................................ 1
CHAPITRE 1 : RAPPEL DES NOTIONS ................................................................................ 3
I. Les notions de la programmation orientée objet ............................................................. 3
1) Les concepts d’objet et d’encapsulation.......................................................................... 3
2) Le concept de classe ........................................................................................................ 3
3) L’héritage ........................................................................................................................ 3
4) Le polymorphisme........................................................................................................... 4
II. Présentation du langage ................................................................................................... 4
1) Origines du langage ......................................................................................................... 4
2) Le langage Java est simple, familier et orienté objet ...................................................... 4
3) Le langage Java est distribué ........................................................................................... 4
4) Le langage Java est robuste et sûr ................................................................................... 4
5) Le langage Java est portable et indépendant des plates-formes : .................................... 5
6) Le langage Java est dynamique et multithread................................................................ 5
7) Java et la programmation événementielle ....................................................................... 5
a) Les programmes à interface console (ou en ligne de commande) ............................... 5
b) Les programmes à interface graphique (G.U.I.) .......................................................... 5
c) Applications et applets................................................................................................. 5
8) Le programme « Hello World » ...................................................................................... 6
III. Outils de développement et utilitaires ............................................................................. 6
1) La plate-forme de développement JAVA........................................................................ 6
2) Les Environnement de développement JAVA ................................................................ 6
3) L’utilitaire JavaDoc ......................................................................................................... 7
IV. LES BASES DU LANGAGE JAVA .............................................................................. 8
1) Les types de Base ............................................................................................................ 8
2) La déclaration des variables ............................................................................................ 8
3) Les opérateurs ................................................................................................................. 8
4) Conversion de type .......................................................................................................... 8
5) Les structures de contrôle ................................................................................................ 9
a) Les principales différences avec le C .......................................................................... 9
b) If................................................................................................................................... 9
c) Switch .......................................................................................................................... 9
d) While ......................................................................................................................... 10
e) For .............................................................................................................................. 10
f) Break et continue ....................................................................................................... 10
6) Les commentaires .......................................................................................................... 11
CHAPITRE 2 : LA PROGRAMMATION OBJET ................................................................. 12
I. CLASSES ET OBJET ................................................................................................... 12
1) Les classes ..................................................................................................................... 12
a. Définition ................................................................................................................... 12
b. Déclaration et instanciation des classes ..................................................................... 12
c. Les attributs (les champs) .............................................................................................. 12

M. GBOLOVI 1 Cours JAVA

 d. Les méthodes ................................................................................................................. 13
e. Les constructeurs ....................................................................................................... 15
2) La référence sur l'objet courant : this ............................................................................ 16
3) Droit d’acces (Encapsulation) ....................................................................................... 16
4) Les accesseurs et les mutateurs ..................................................................................... 17
5) La référence vide : null .................................................................................................. 18
6) Les tableaux................................................................................................................... 18
a) Création et utilisation d’un tableau ............................................................................ 18
b) Affectation de tableaux .............................................................................................. 19
c) La taille d’un tableau : length .................................................................................... 20
d) Exemple de tableau d’objets ...................................................................................... 20
II. L’HERITAGE ............................................................................................................... 21
1) Principes généraux, le mot clé extends ......................................................................... 21
2) Accès à la super-classe d'une classe : super(…) ........................................................... 22
III. Le Polymorphisme ........................................................................................................ 23
IV. Méthodes et classes abstraites : abstract ....................................................................... 24
a) Les classes abstraites ................................................................................................. 24
b) Les méthodes abstraites ............................................................................................. 25
V. LES INTERFACES ....................................................................................................... 26
1) Définitions, les mots clés interface et implements. ....................................................... 26
CHAPITRE 3 : LES PACKAGES ET LES EXCEPTIONS .................................................... 27
VI. LES PACKAGES .......................................................................................................... 27
1) Les packages ................................................................................................................. 27
2) La structure de stockage des classes et des packages.................................................... 28
3) Les principaux packages du JDK .................................................................................. 28
VII. LES EXCEPTIONS ...................................................................................................... 29
1) Pourquoi des exceptions ? ............................................................................................. 29
2) Représentation et déclenchement des exceptions : classe Exception, opérateur throw 29
3) Propagation, Capture et traitement des exceptions ....................................................... 29
a) Propagation des exceptions : le mot clé throws ......................................................... 29
b) Capture des exceptions : catch, try et finally ............................................................. 30
CHAPITRE 4 : INTERFACE GRAPHIQUE AVEC SWING ............................................... 32
Introduction .............................................................................................................................. 32
1) Les conteneurs .................................................................................................................. 32
2) Les composants ................................................................................................................. 33
3) Les gestionnaires de disposition ....................................................................................... 34
4) La gestion des événements................................................................................................ 35
a) Les boîtes de message ................................................................................................... 38
b) Les boîtes de confirmation ............................................................................................ 39
CHAPITRE 5: LE RESEAU .................................................................................................... 41
1) Définitions ..................................................................................................................... 41
2) Les classes URL et URLConnection ............................................................................. 42
3) Les sockets .................................................................................................................... 42
Présentation ....................................................................................................................... 42
a) Le client : classes InetAddress et Socket ................................................................... 42
b) Le serveur : classes ServerSocket et Socket .............................................................. 43

M. GBOLOVI 2 Cours JAVA

CHAPITRE 1 : RAPPEL DES NOTIONS
I. Les notions de la programmation orientée
objet
La P.O.O. (programmation orientée objet) possède de nombreuses vertus universellement
reconnues désormais. Notamment, elle se fonde sur la programmation structurée, elle
contribue à la fiabilité des logiciels et elle facilite la réutilisation de code existant. Elle
introduit de nouveaux concepts, en particulier ceux d’objets, d’encapsulation, de classe
d’héritage et de polymorphisme.

1) Les concepts d’objet et d’encapsulation

En programmation structurée, un programme est constitué de sous programmes (fonctions et
procédures) et de structures de données généralement indépendants.
En P.O.O., un programme met en œuvre différents objets. Chaque objet associe des données
et des sous programmes agissant exclusivement sur les données de l’objet. On parlera de
méthodes et d’attributs pour désigner les sous programmes et les données.
En P.O.O, on réalise ce que l’on nomme une encapsulation des données.
Cela signifie qu’il n’est pas possible d’agir directement sur les données d’un objet sans passer
par ses méthodes, qui jouent ainsi le rôle d’interface obligatoire. Ainsi l’appel d’une méthode
est en fait l’envoi d’un message à l’objet.
L’intérêt du principe de l’encapsulation est que, vu de l’extérieur, un objet se caractérise
uniquement par les spécifications de ses méthodes, la manière dont sont réellement implantées
les données étant sans importance. Elle réalise donc une abstraction des données.
L’encapsulation des données présente augmente manifestement la qualité de logiciel.
Elle facilite considérablement la maintenance : une modification éventuelle de la structure des
données d’un objet n’a d’incidence que sur l’objet lui-même ; les utilisateurs de l’objet ne
seront pas concernés par la teneur de cette modification. De la même manière, l’encapsulation
des données facilite la réutilisation d’un objet.

2)Le concept de classe

Le concept de classe correspond simplement à la généralisation de la notion de type que l’on
rencontre dans les langages classiques. En effet, une classe n’est rien d’autre que la
description d’un ensemble d’objets ayant une structure de données commune et disposant des
mêmes méthodes. Les objets encore appelé instance sont comme des variables d’un tel type
classe. Bien entendu, seule la structure est commune, les valeurs des attributs ou champs étant
propres à chaque objet. En revanche, les méthodes sont effectivement communes à l’ensemble
des objets d’une même classe.

3)L’héritage
Un autre concept important en P.O.O. est celui d’héritage. Il permet de définir une nouvelle
classe à partir d’une classe existante, à laquelle on ajoute de nouvelles données et de
nouvelles méthodes. La conception de la nouvelle classe, qui hérite des propriétés et des
méthodes, peut ainsi s’appuyer sur des réalisations antérieures parfaitement au point et les
spécialiser à volonté. Comme on peut s’en douter, l’héritage facilite largement la réutilisation
de produits existants.
Cette technique s’appliquera aussi bien aux classes que vous serez amenés à développer
qu’aux très nombreuses classes fournies en standard avec Java.

M. GBOLOVI 3 Cours JAVA

Certains langages, tels C++, offrent la possibilité d’un héritage multiple : une même classe
peut hériter simultanément de plusieurs autres. Ce n’est pas le cas de Java, mais nous verrons
que la notion d’interface permet de traiter plus élégamment les situations correspondantes.

4)Le polymorphisme
En Java, comme généralement, en P.O.O., une classe peut redéfinir certaines des méthodes
héritées de sa classe de base. Cette possibilité est la clé du polymorphisme, c’est-à-dire la
possibilité de traiter de la même manière des objets de types différents, pour peu qu’ils soient
issus de classes dérivées d’une même classe de base. Plus précisément, on utilise chaque objet
comme s’il était de cette classe de base, mais son comportement effectif dépend de sa classe
effective (dérivée de cette classe de base), en particulier de la manière dont ses propres
méthodes ont été redéfinies.

II. Présentation du langage

1)Origines du langage
Java a été développée par SunSoft (branche de Sun MicroSystems) pour réaliser le
développement de systèmes embarqués.
La société Oracle a acquis en 2009 l'entreprise Sun Microsystems. On peut désormais voir
apparaître le logo Oracle dans les documentations de l'api Java.
Le langage est actuellement utilisé dans de nombreux domaines de l’informatique : Réseaux
/Internet (qui l’a rendu célèbre), applications clients/serveurs, systèmes embarqués (Voitures,
TV, Téléphones portables,… machines à laver),…
Java est un langage qui s’inspire de la syntaxe de C++ et de la gestion dynamique de la
mémoire de SmallTalk, deux langages orientés objets.

2)Le langage Java est simple, familier et orienté objet

Java est un langage simple car il n'utilise qu'un nombre restreint de nouveaux concepts. Sa
syntaxe est très proche du langage C, ce qui le rend familier aux programmeurs C et C++. Java
épure le C++ de toutes les faiblesses qui occupent une partie non négligeable du temps de
développement.
Java est un langage orienté objet : un programme Java est centré complètement sur les objets
et fournit un ensemble prédéfini de classes facilitant la manipulation des entrées-sorties, la
programmation réseau, système, graphique. Excepté les types de données fondamentaux, tout
est objet ! Seule l'héritage simple existe en Java.

3)Le langage Java est distribué

Conçu pour développer des applications en réseaux, les manipulations des objets distants ou
locaux se font de la même manière. La classe Socket permet la programmation d'applications
Client/Serveur de manière aisée.

4)Le langage Java est robuste et sûr

Le langage Java est fortement typé ; il élimine bien des erreurs d'incohérence de type à la
compilation. La suppression de la manipulation des pointeurs permet également de réduire de
manière importante les erreurs. Un glaneur de mémoire rendu libre permet de décharger le
programmeur d'une gestion fastidieuse de la mémoire.
Destiné pour des applications réseaux, la sécurité dans Java est un aspect primordial.

M. GBOLOVI 4 Cours JAVA

 5)Le langage Java est portable et indépendant des
plates-formes :
Pour être portable, un programme Java n'est pas compilé en code machine ; il est transformé
en code intermédiaire interprété.
Le code intermédiaire produit est indépendant des plates-formes : il pourra être exécuté sur
tous types de machines et systèmes pour peu qu'ils possèdent l'interpréteur de code Java
notamment la JVM (Java Virtual Machine). Même la programmation graphique, réseau et
système est totalement indépendant des machines et systèmes.

6)Le langage Java est dynamique et multithread

Le langage Java est dynamique et s'adapte à l'évolution du système sur lequel il s'exécute.
De nos jours, les applications possèdent un haut degré de parallélisme : il faut pouvoir écouter
une musique, tout en voyant une animation graphique etc. Java permet le mutlithreading de
manière simple.

7)Java et la programmation événementielle

Actuellement, on peut distinguer deux grandes catégories de programmes, en se fondant sur
leur interface avec l’utilisateur:
 les programmes à interface console,
 les programmes à interface graphique.

a) Les programmes à interface console (ou en ligne de commande)

Historiquement, ce sont les plus anciens. Dans de tels programmes, on fournit des
informations à l’écran sous forme de lignes de texte s’affichant séquentiellement, c’est-à-dire
les unes à la suite des autres. Pour fournir des informations au programme, l’utilisateur frappe
des caractères au clavier (généralement un "écho" apparaît à l’écran).
Avec une interface console, c’est le programme qui décide de l’enchaînement des opérations :
l’utilisateur est sollicité au moment voulu pour fournir les informations demandées.
b) Les programmes à interface graphique (G.U.I.)
Dans ces programmes, la communication avec l’utilisateur se fait par l’intermédiaire de
composants tels que les menus déroulants, les menus surgissant, les barres d’outils ou les
boîtes de dialogue, ces dernières pouvant renfermer des composants aussi variés que les cases
à cocher, les boutons radio, les boîtes de saisie, les listes déroulantes...
L’utilisateur a l’impression de piloter le programme, qui semble répondre à n’importe laquelle
de ses demandes. D’ailleurs, on parle souvent dans ce cas de programmation événementielle,
expression qui traduit bien le fait que le programme réagit à des évènements provoqués par
l’utilisateur.
Ce genre d’interface est désigné par le thème G.U.I. (Graphical User Interface).
Manifestement, il met en avant le fait que, pour permettre ce dialogue, on ne peut plus se
contenter d’échanger du texte et qu’il faut effectivement être capable de dessiner, donc
d’employer une interface graphique.
c) Applications et applets
À l’origine, Java a été conçu pour réaliser des applets s’exécutant dans des pages Web. En
fait, Java permet d’écrire des programmes indépendants du Web.
Les fonctionnalités graphiques à employer sont quasiment les mêmes pour les applets et les
applications.
Une applet est faite pour que son code (compilé) soit téléchargé dans une page Web.
Cependant, les environnements de développement disposent des outils pour visualiser
d’applets permettant d’exécuter une applet en dehors du Web.

M. GBOLOVI 5 Cours JAVA

 8)Le programme « Hello World »
Avant d’aller plus en avant dans ce cours, voici l’exemple le plus simple de programmation Java :

public class Hello {

public static void main(String argv[])
{
System.out.println("Hello World") ;
}
}

Les étapes nécessaires pour l’exécuter dans une fenêtre DOS sans outils de développement
visuel (uniquement avec le JDK) sont:
C:> javac Hello.java <= Compilation : création de Hello.class
C:> java Hello <= Lancement du programme à partir de la machine virtuelle
Hello World
C:>

III. Outils de développement et utilitaires

1)La plate-forme de développement JAVA

Le JDK (Java Development Kit) est l’outil de base pour tout développement Java. Ce kit
contient tout le nécessaire pour développer des applications ou des applets Java : Le
compilateur (en ligne de commandes), une machine virtuelle, un ensemble complet de classes
de bases regroupées en packages.
Différents outils du commerce fournissent des interfaces graphiques permettant d’encapsuler
le JDK. Une partie des développements peut alors être réalisée de manière visuelle.

2)Les Environnement de développement JAVA

a. Eclipse
Eclipse est un environnement de développement (IDE) historiquement destiné au langage
Java, même si grâce à un système de plugins il peut également être utilisé avec d'autres
langages de programmation, dont le C/C++ et le PHP.

Eclipse nécessite une machine virtuelle Java (JRE) pour fonctionner. Mais pour compiler du
code Java, un kit de développement (JDK) est indispensable.
Eclipse est un projet, décliné et organisé en un ensemble de sous-projets de développements
logiciels, de la fondation Eclipse visant à développer un environnement de production de
logiciels libre qui soit extensible, universel et polyvalent, en s'appuyant principalement sur
Java.
b. NetBeans
Créé en 1996 sur les bases d'un projet étudiant, NetBeans est environnement de
développement intégré (ou IDE) racheté par Sun Microsystèms (eux-mêmes racheté par
Oracle en 2009).

Son parcours explique ainsi sa forte orientation pour le Java bien que le logiciel, qui continue
à évoluer, permette également de gérer des développements en JavaScript, Python, XML,
RubyC et C++ ainsi qu'en PHP et HTML5.

M. GBOLOVI 6 Cours JAVA

NetBeans intègre la plupart des fonctionnalités exigées d'un IDE moderne dont, bien sûr, un
éditeur de code gérant l'auto indentation et la colorisation :

 Gestion des systèmes de versions CVS, Subversion, Mercurial et ClearCase,

 Analyses en « run » et débogage,
 Explorateur de base de données.
 Édition graphique d'interfaces et de pages Web,

NetBeans IDE vous permet non seulement de créer d'étonnantes applications de bureau, mais
aussi des applications mobiles et web pour téléphones intelligents et ordinateurs de poche,
sans avoir à changer la programmation.

3)L’utilitaire JavaDoc
Javadoc est un outil développé par Oracle, permettant de créer une documentation d'API en
format HTML depuis les commentaires présents dans un code source en Java.

Conçu à l'origine par Sun MicroSystems (avant son rachat par Oracle), javadoc est le standard
industriel pour la documentation des classes Java. La plupart des IDE génèrent
automatiquement la javadoc au format HTML.

Lorsqu'ils commentent le code-source, les développeurs Java peuvent signaler qu'un

commentaire doit être intégré dans la documentation à l'aide d'une syntaxe spéciale. Un bloc
de commentaire Java commençant par /** deviendra un bloc de commentaire Javadoc qui
sera inclus dans la documentation du code source. Les commentaires Javadoc précèdent
généralement les déclarations de classes, d'attributs et de méthodes. Un tag Javadoc
commence par un @ (arobase). Le tableau suivant présente certains des tags les plus courants :

Tag Description
@author Nom du développeur
@deprecated
Marque la méthode comme dépréciée. Certains IDEs créent un
avertissement à la compilation si la méthode est appelée.
@exception
Documente une exception lancée par une méthode — voir aussi
@throws.
@param Définit un paramètre de méthode. Requis pour chaque paramètre.
Documente la valeur de retour. Ce tag ne devrait pas être employé
@return pour des constructeurs ou des méthodes définies avec un type de
retour void.
@see Documente une association à une autre méthode ou classe.
@since
Précise à quelle version de la SDK/JDK une méthode a été ajoutée à la
classe.
@throws
Documente une exception lancée par une méthode. Un synonyme pour
@exception disponible depuis Javadoc 1.2.
@version Donne la version d'une classe ou d'une méthode.

M. GBOLOVI 7 Cours JAVA

IV. LES BASES DU LANGAGE JAVA
La plupart de ces éléments sont des reprises directes du langage C++.
1)Les types de Base
Java dispose de types de base comme le langage C++. Ils constituent malgré tout une entorse
à la pureté du modèle objet de Java. Ces éléments ressemblent à des objets, mais ne sont pas
des objets. Cependant ils peuvent être enveloppés dans des objets spécialement conçu à cet
effet, et appelés enveloppeurs (wrappers).
Les types de base sont :
Taille Valeurs Normes Valeur inférieure Valeur supérieure
Byte 1 octet signé Format IEEE -256 255
Short 2 octets Signé Format IEEE -32768 32767
Int 4 octets Signé Format IEEE -2147483648 2147483647
Long 8 octets Signé Format IEEE -9223372036854775808 9223372036854775807
Float 4 octets Signé Format IEEE
Double 8 octets Signé Format IEEE
Char 2 octets Codage Unicode
boolean 1 bit 2 valeurs : true ou false false true

2)La déclaration des variables

Les exemples suivants montrent que la forme des déclarations et le format des variables sont
similaires au langage C++ :
byte b = 67 ;
short si = -24000 ;
int i = 42000 ;
long l1 = 600000000 ;
long l2 = 0xA05 ; // En hexadécimal
int i2 = 067 ; // en octal
float f = 23.456
double d = 23.8 e34 ;

boolean b = true ;

char c1 = 'a' ;
char c2 = 48 ; // Unicode
int i2 = 'a' ;
String s = "Bonjour \n" ;
Attention : String n'est pas un type de base, mais une classe. Nous reviendrons dessus plus
tard. En tout état de cause, String n'a rien à voir avec un tableau ou un pointeur.
3)Les opérateurs
Ce sont les mêmes que dans le langage C++ :
Types d'opérateurs Listes des opérateurs Types concernés
Binaire +, -, *, /, %
Arithmétiques Unaire -, --, ++ Entiers et réels (sauf le modulo)
Etendus +=, -=, *=, /=
Binaires bit à bit ~, &, ^,<<, >> Entiers
Logiques !, &&, || Booléens
De comparaison (le résultat est de type ==, !=, <, <=, >, >= Tous les types (y compris les références
boolean) d'objets)

4)Conversion de type
Il existe les conversions implicites et explicites possibles:

M. GBOLOVI 8 Cours JAVA

  Conversion explicite
 Conversion implicite lors d'une affectation ; Conversion implicite lors d'une promotion
arithmétique (un opérateur s'applique toujours sur deux arguments de même type : si
ce n'est pas le cas, un des deux arguments sera converti dans le type de l'autre ; Et la
Conversion implicite lors d'un passage de paramètres (appel d’une méthode).
int i, j ;
short s=2;
float f = 1.2 ;
i = (int) f ; // conversion explicite : float => int
i=s; // conversion implicite lors d'une affectation : short => int
f = i / 2.0 ; // conversion par promotion arithmétique : int => float
// Méthode définie par : int objet.meth( int arg )
objet.meth(s) ; // conversion lors d'un passage de paramètre : short => int
Les conversions pouvant provoquées une perte de valeur ne sont pas autorisées de manière
implicite dans JAVA : cela doit être explicitement demandé :
int i, j ;
short s=2;
float f = 1.2 ;
i=f; // conversion implicite : float => int !!!! ERREUR A LA COMPILATION
Il n'y a pas de conversion possible (implicite ou explicite) entre un type entier et le type
boolean .
5)Les structures de contrôle
Dans un programme, chaque instruction est exécutée une fois. Cependant, il est quelque fois
nécessaire d’exécuter une ou plusieurs instructions plusieurs fois jusqu’à ce qu’une condition
soit satisfaite. Avec Java, il y a trois façons de créer des boucles : boucles while, do et for..
a) Les principales différences avec le C
L'instruction goto n'existe plus ! (Enfin…)
Les expressions logiques sont de type boolean, pas de type entier.
b) If
class IfApp {
public static void main(String args[]) {
int c = 0 ;
if ( c == 1 ) System.out.println( " Jamais imprimé " ) ;
else System.out.println( " Ceci sera imprimé" ) ;
}
}
Remarque : L'expression logique attendue est obligatoirement de type boolean.
c) Switch
Dans l’instruction switch :
 Les blocs de code sont exécutés selon la valeur d’une variable ou d’une expression,
pas d’une condition.
 La valeur de l’expression doit être de type nombre entier (ou d’un type qui peut être
transtypé en int sans risque, comme char).
 Les valeurs case doivent être des expressions constantes du même type que
l’expression.
 Le mot clé break est facultatif. Il est nécessaire pour terminer l’exécution de
l’instruction switch une fois qu’un bloc de code s’exécute.

class SwitchApp {
public static void main(String args[]) {

M. GBOLOVI 9 Cours JAVA

 System.out.println( " Entrez A, B ou C : " ) ;
char c = (char) Lecture.lireString( ) ;
switch ( c ) {
case 'a' : case 'A' :
System.out.println( " A " ) ;
break ;
case 'b' : case 'B' :
System.out.println( " B " ) ;
break ;
case 'c' : case 'C' :
System.out.println( " C " ) ;
break ;
default :
System.out.println( " Erreur " ) ;
break ;
} }
}

d) While
class WhileApp {
public static void main(String args[]) {
int c ;
do {
System.out.println("Entrez un nombre positif <= 5") ;
c = LireEntier( ) ;
} while ( c <= 0 || c > 5 ) ;
while ( c > 0 ) System.out.println( c-- ) ;
}
public static int LireEntier() { /*fonction à definir */ }
}
e) For
public class InstructionFor
{
public static void main (String args[])
{
for (int i=1, j=1; (i <= 5); i++, j+=i)
{
System.out.println ("i= " + i + " j= " + j);
}
}}
f) Break et continue
 break : L’instruction break permet de sortir d’une structure de boucle avant que la
condition du test soit respectée. Quand la boucle rencontre une instruction break, elle
se termine immédiatement en ignorant le code restant. Exemple :
int x = 0;
while (x < 10){
System.out.println("Bouclage");
x++;
if (x == 5)
break;
else
System.out.println("Boucle continue");
}

M. GBOLOVI 10 Cours JAVA

  continue : permet de passer immédiatement à l'itération suivante de la boucle
concernée.
for ( int x = 0 ; x < 10 ; x++){
if(x == 5)
continue; //revient au début de la boucle avec x=6
System.out.println("Bouclage");
}
Cet exemple n’imprime pas “Bouclage” si x a la valeur 5.

6)Les commentaires
Java supporte deux types de commentaires :
 Tout ce qui se trouve entre /* et */ est un commentaire
 Tout ce qui sur une ligne se trouve après // est un commentaire
class Hello { /* ceci est uncommentaire */
public static void main(String argv[])
{
System.out.println("Hello World") ; // autre commentaire
}
}

M. GBOLOVI 11 Cours JAVA

 CHAPITRE 2 : LA
PROGRAMMATION OBJET
JAVA est presque un pur langage de programmation Orienté Objet(POO), Tout est donc
objet sauf les types de base. Ce qui signifie que le niveau le plus externe de la structure des
données est l’objet. Dans Java, il n’y a pas de constantes, variables ou fonctions autonomes ;
l’accès se fait toujours par des classes et des objets.

I. CLASSES ET OBJET
1)Les classes
Tout d’abord, il faut faire la distinction entre les classes et les objets. Une classe est la
définition d’un type, alors que l’objet est une déclaration de variable.
Le processus de création d’un objet à partir d’une classe est appelé instanciation d’un objet
ou création d’une occurrence d’une classe.

a. Définition
La classe regroupe la définition des membres de classe, c’est-à-dire :
- des méthodes, les opérations que l’on peut effectuer ;
- des champs ou attribut, les variables que l’on peut traiter ;
- des constructeurs, qui sont des méthodes permettant de créer des objets ;
b. Déclaration et instanciation des classes
Une classe Java peut être très simple. Voici la définition d’une classe vide :
class MaClasse {
}
Evidemment, cette classe n’est pas encore utile, mais elle est correcte dans Java. Mais
commençons par étudier la syntaxe de l’instanciation d’une classe. Pour créer une occurrence
de cette classe, il faut créer une référence :
MaClasse monObjet;
Mais cette instruction n’affecte ni mémoire ni autres ressources à l’objet. Elle crée une
référence appelée monObjet, mais n’instancie pas l’objet. C’est le rôle de l’opérateur new.
monObjet = new MaClasse();
Après l’exécution de cette ligne de code, il est possible d’accéder aux variables et aux
méthodes membres de la classe avec l’opérateur “.”.
Une fois l’objet créé, vous n’avez pas à vous préoccuper de sa destruction. Dans Java, les
objets sont automatiquement éliminés par le Garbage collector. Dès que la référence à un
objet (c’est-à-dire la variable) sort de la portée, la machine virtuelle libère automatiquement
toutes les ressources affectées par l’opérateur new.
c. Les attributs (les champs)
Les attributs (ou champs) sont les données contenues dans les objets d'une certaine classe.
 Déclaration et initialisation
Voici un exemple plus complexe de classe, décrivant des objets représentants des dates et
contenant trois attributs :

M. GBOLOVI 12 Cours JAVA

 class Date {
int jour ; // Par défaut, un attribut est initialisé à zéro
int mois = 1 ;
int an = 2000 ;
final int MAX_MOIS = 12 ; // Ceci est une constante : elle doit être initialisée
Date(int _an) { an = _an; } // Ceci est un constructeur, méthode spéciale utilisée lors
// de la création d'objets. Nous verrons cette notion en
// détail plus tard.
void print() { System.out.println( jour + "/" + mois + "/" + an ); }
}
…
Date d = new Date(1998) ;// Création d'un nouvel objet de la classe Date, d est une référence
// sur cet objet. Nous reviendrons sur ces notions plus tard
// Invocation de la méthode print sur l'objet référencé par d
d.print() ; // => affiche : 0/1/1998
 Le mot clé : final
Le mot clé final, utilisé pour un attribut, permet de spécifier que cet attribut est une constante.
Une variable qualifiée de final signifie que la valeur de la variable ne peut plus être modifiée
une fois que celle-ci est initialisée.
public class Constante2 {
public final int constante;
public Constante2() {
this.constante = 10;
}
}
 Les attributs statiques
Le mot clé static, utilisé pour un attribut, permet d'indiquer que cet attribut est commun à tous
les objets de la classe concernée : il s'agit d'un attribut de la classe elle-même, et si on modifie
cet attribut pour un objet donné, il sera modifié pour tous les objets de la classe (puisque c'est
le même).
class Voiture {
static int count = 0 ;
int id ;
Voiture() { id = count++ ; }
}
…
Voiture v1 = new Voiture() ;
Voiture v2 = new Voiture() ;
Un attribut de classe peut être accédé par n'importe quel nom de référence associé à un objet
de cette classe, ou par le nom de la classe elle-même.
d. Les méthodes
Une méthode peut être considérée comme une fonction qui est membre d'une certaine classe :
Les méthodes Java sont syntaxiquement très proches des fonctions C : elles ont un nom,
peuvent accepter des paramètres et retourner une valeur. Cependant lors de la définition des
méthodes, l’implémentation de la méthode figure juste sous la déclaration.
 Le passage des paramètres
Il est très important de comprendre la différence entre le comportement des types de base et
celui des objets lors du passage de paramètres.
 Les types de bases : passage de paramètres par valeur
Les types de base sont toujours passés par valeur : lors de l'appel d'une méthode, les variables
utilisées lors de l'appel ne sont donc pas modifiées par celui-ci.

M. GBOLOVI 13 Cours JAVA

 class Point {
private int x, y ;
public void setXY(float newx, float newy) { x = newx++ ; y = newy++ ; }
}
…
int a = 0 , b = 0 ;
Point p = new Point() ;
p.setXY(a,b) ;
// a et b valent toujours zéro…

 Les objets : passage de paramètres par adresse

Lorsque l'on passe en paramètre un objet, c'est la référence sur cet objet qui est dupliqué. Il
n'y a donc pas duplication de l'objet lui-même. Si la méthode modifie l'objet, il sera donc
toujours modifié après l'appel à cette méthode.
class PointValue {
public int x,y ;
}
class point {
private int x, y ;
public void setXY(PointValue nv) { x = nv.x++ ; y = nv.y++ ; }
} Objet référencé par pv
… pv
PointValue pv = new PointValue() ;
Point p = new Point() ; x: y:
pv.x = 0 ;
pv.y = 0 ;
p.setXY(pv) ; new
// pv.x et pv.y valent maintenant un…

 La surcharge des méthodes

La surcharge permet de définir des méthodes portant le même nom, mais acceptant des
paramètres de type différents et/ou en nombre différent. En fonction du type et du nombre des
paramètres passés lors de l'appel, c'est une version ou une autre de la méthode qui sera
effectivement appelée.
Attention : Le type de retour d'une méthode ne permet pas de différencier deux méthodes
portant le même nom (si c'est la seule différence).
class Test {
void print(int i) { … }
void print(float f) { … }
void print(int i, int j) { … }
}
…
Test t = new Test() ;
int i ;
t.print( i ) ; // => La première méthode est appelée

A l'appel, la machine virtuelle Java détermine quelle est la méthode dont la liste de paramètres
est la plus proche des paramètres effectivement envoyés. Dans le cas d'un appel de méthode
avec des types ne correspondants pas exactement, des conversions implicites peuvent être
effectuées.
short s ;
t.print( s ) ; // => La première méthode est appelée avec une conversion de s en int

M. GBOLOVI 14 Cours JAVA

  Les méthodes statiques
Il est possible de définir une méthode de type statique avec static. De même que pour les
attributs, cela signifie que les actions de cette méthode concernent la classe entière. Pour cette
raison, une méthode statique, ne peut accéder qu’aux attributs statiques de la classe.
On peut invoquer une méthode statique soit sur la classe elle-même, soit sur un objet de cette
classe. Dans tous les cas elle s'appliquera sur la classe entière.
L'utilisation d'une méthode statique ne nécessite pas la construction d'un objet appartenant à la
classe correspondante.

class MathTool {
final static double PI = 3.14 ;

static double getPI() { return PI ; }

static double diametre( double rayon ) { return 2*PI*rayon ; }
static double power(double x) { return x * x ; }
}

class Test {
void methode1() {
double i = MathTool.power(6) ; /* invocation d'une méthode static sur une classe */
}
void methode2() {
MarhTool tool = new MathTool() ;
double i = tool.power(6) ; /* idem mais sur un objet. La première méthode est
plus logique */
}

Enfin, la première utilisation du mot clé static concerne la méthode main, dont une version
peut être définie pour chaque classe et qui sera la première méthode appelée, si et seulement si
on lance la Machine Virtuelle Java directement avec cette classe.
class Voiture {
// Méthode utilisée si cette classe est exécutée directement
public static void main(String args[]) {
Voiture v1 = Voiture.getVoiture(435)
v1.print() ;
}
// Gestion des objets de la classe
static ListeDeVoiture liste ;

static Voiture getVoiture( int numero ) {

… retourne l'objet voiture correspondant, à partir de la liste
}
static Voiture newVoiture(int numero) {
Voiture v = new Voiture(numero) ;
… insertion de v dans la liste
}
// Description du comportement de chaque objet Voiture
Voiture(int numero) { … }
void print() { … }
…
}

e. Les constructeurs
Un constructeur est une méthode particulière qui permet d'initialiser les objets de la classe
concernée. Chaque fois qu'un objet est construit avec l'opérateur new, un constructeur est
automatiquement appelé.

M. GBOLOVI 15 Cours JAVA

Un constructeur a le même nom que la classe, ne retourne jamais de valeur et peut prendre des
paramètres.
Lorsqu'une classe ne comporte pas de constructeur, le compilateur génère un constructeur par
défaut qui ne prend aucun paramètre, et qui initialise tous les attributs à zéro.
Il est possible de définir plusieurs constructeurs pour une même classe.
class Date {
int _jour =1 ;
int _mois =1 ;
int _an =1990 ;
Date( ) { _an = 2000 ; }
Date( int an ) { _an = an ; }
Date( int jour, int mois, int an ) { _jour = jour ; _mois = mois ; _an = an ; }
}
La classe précédente contient trois constructeurs.
Le finaliseur
Comme nous l’avons déjà signalé, Java n’a pas de mécanisme destructeur, puisque ce langage
prend soin de libérer toutes les ressources pour vous. Cependant, certaines situations
nécessitent un nettoyage spécial que le Garbage collector ne peut pas effectuer quand la classe
disparaît. Par exemple, certains fichiers ont été ouverts pendant la durée de vie de l’objet et
vous voulez vérifier qu’ils sont correctement fermés quand l’objet est détruit. Un finaliseur est
appelé par le Garbage collector immédiatement avant la destruction de l’objet. Ainsi, si un
nettoyage spécial quelconque doit avoir lieu, le finaliseur peut le faire pour vous. Cependant,
le Garbage collector s’exécute dans la machine virtuelle sous forme de thread de faible
priorité, ce qui ne permet pas de savoir à quel moment il détruira réellement votre objet. Pour
créer un finaliseur, il faut redéfinir la méthode finalize() héritée de la classe Object.

2)La référence sur l'objet courant : this

Le mot-clé this représente une référence sur l'objet courant (celui qui est en train d'exécuter la
méthode dans laquelle se trouvent les instructions concernées).
this peut être utile :
 Lorsqu'une variable locale (ou un paramètre) "cache", en portant le même nom, un
attribut de la classe.
 Pour déclencher un constructeur depuis un autre constructeur.
class Date {
int jour =1 ;int mois =1 ;int an =1990 ;
Date( ) { an = 2000 ; } /* peut aussi s'écrire : this.an = 2000 */
Date( int an ) {
this.an = an ; } /* Le paramètre an cache l'attribut an */
Date( int jour, int mois, int an ) {
this.jour = jour ;
this.mois = mois ;
this(an) ; /* appel du deuxième constructeur */
}}

3)Droit d’acces (Encapsulation)

L’encapsulation consiste à masquer l’accès à certains attributs et méthodes d’une classe.
Elle est réalisée à l’aide des mots clés :
 private : les membres privés ne sont accessibles que par les fonctions membres de la
classe.
 protected : les membres protégés sont comme les membres privés. Mais ils sont aussi
accessibles par les fonctions membres des classes dérivées (voir l’héritage).

M. GBOLOVI 16 Cours JAVA

  public : les membres publics sont accessibles par tous. La partie publique est appelée
interface.
class Document{
private String titre ;
protected int nbrePage ;
public Document(String t,int np){
titre= t ;
nbrePage=np ;
}}

4)Les accesseurs et les mutateurs

 La protection des données membres
L'un des aspects les plus essentiels du concept « orienté objet » est l'encapsulation, qui
consiste à définir des étiquettes pour les données membres et les fonctions membres afin de
préciser si celles-ci sont accessibles à partir d'autres classes ou non...
De cette manière, des données membres portant l'étiquette private ne peuvent pas être
manipulées directement par les fonctions membres des autres classes. Ainsi, pour pouvoir
manipuler ces données membres, on doit prévoir à cet effet des fonctions membres spéciales
portant l'étiquette public.
 Les fonctions membres permettant d'accéder aux données membres sont appelées
accesseurs, parfois getter (appellation d'origine anglophone)
 Les fonctions membres permettant de modifier les données membres sont appelées
mutateurs, parfois setter (appellation d'origine anglophone).
 La notion d'accesseur
Un accesseur est une méthode permettant de récupérer le contenu d’un attribut. Un accesseur,
pour accomplir sa fonction :
 doit avoir comme type de retour le type de l’attribut à renvoyer,
 ne doit pas nécessairement posséder d'arguments.
Une convention de nommage veut que l'on fasse commencer de façon préférentielle le nom de
l'accesseur par le préfixe get.
Exemple
class Document{
private String titre ;
protected int nbrePage ;
String getTitre(){
return titre ;
}
int getNbrePage(){ return nbrePage ;}
}
 La notion de mutateur
Un mutateur est une méthode permettant de modifier le contenu d’un attribut. Un mutateur,
pour accomplir sa fonction :
 doit avoir comme paramètre la valeur à assigner à la donnée membre. Le paramètre
doit donc être du type de l’attribut,
 ne doit pas nécessairement renvoyer de valeur (il possède dans sa plus simple
expression le type void).
Une convention de nommage veut que l'on fasse commencer de façon préférentielle le nom du
mutateur par le préfix set.
Exemple complet
class Document{

M. GBOLOVI 17 Cours JAVA

 private String titre ;
protected int nbrePage ;
public Document(String t,int np){
titre= t ;
nbrePage=np ;
}
public void affiche(){
System.out.println(“le titre est “+titre+“ le nombre de page est “+nbrePage) ;
}
String getTitre(){ return titre ;}
int getNbrePage(){ return nbrePage ;}
void setTitre(String t){ titre=t;}
void setNbrePage (int nb){ nbrePage=nb;}
}

L'intérêt principal d'un tel mécanisme est le contrôle de la validité des données membres qu'il
procure. En effet, il est possible (et même conseillé) de tester la valeur que l'on assigne à une
donnée membre, c'est-à-dire que l'on effectue un test de validité de la valeur de l'argument
avant de l'affecter à l’attribut.

5)La référence vide : null

Le mot clé null permet de représenter la référence qui ne référence rien. On peut assigner
cette valeur à n'importe quelle variable ou attribut contenant une référence.
class Test {
Voiture v1 ; /* Initialisée à null par défaut */
void methode() {
…
if ( v1 == null ) v1 = new Voiture("Volvo") ;
…
}
}

Attention : Si une méthode est invoquée sur une référence égale à null, cela déclenche une
erreur du type NullPointerException.

6)Les tableaux
En programmation, on parle de tableau pour désigner un ensemble d’éléments de même type
désignés par un nom unique, chaque élément étant repéré par un indice précisant sa position
au sein de l’ensemble.
a) Création et utilisation d’un tableau
Un tableau dans Java est toujours un objet, même si les données de ce tableau appartiennent à
un type de base. La taille d'un tableau est fixée définitivement à sa création.
Un tableau étant un objet, il doit être alloué avec l'opérateur new, il est détruit
automatiquement par le Garbage Collector lorsqu'il n'est plus référencé et il est
systématiquement passé par référence lors de l'appel d'une méthode.
// tableau d'entiers
int tab [] = new int[10] ;

// Tableau de 5 références initialisées à null

Voiture tv[] = new Voiture[5] ;
Il existe deux syntaxes pour déclarer un tableau :

M. GBOLOVI 18 Cours JAVA

La syntaxe de C : int tab[] ;
La syntaxe pure Java : int[] tab ;
La syntaxe d'initialisation d'un tableau de type de base est la même que celle du langage C.
Lors de la déclaration d’une référence de tableau, on peut fournir une liste d’expressions entre
accolades, comme dans :
int n, p ;
...
int t[] = {1, n, n+p, 2*p, 12} ;
Cette instruction crée un tableau de 5 entiers ayant les valeurs des expressions mentionnées et
en place la référence dans t. Elle n’est valable que dans une déclaration.
Exemple d’utilisation d’un tableau :
public class Moyenne
{ public static void main (String args[])
{ int i, nbEl, nbElSupMoy ;
double somme ;
double moyenne ;
System.out.print ("Combien d’eleves ") ;
nbEl = Clavier.lireEntier();
double notes[] = new double[nbEl] ;
for (i=0 ; i<nbEl ; i++)
{ System.out.print ("donnez la note numero " + (i+1) + " : " ) ;
notes[i] = Clavier.lireDouble() ;
}
for (i=0, somme=0 ; i<nbEl ; i++) somme += notes[i] ;
moyenne = somme / nbEl ;
System.out.println ("\nmoyenne de la classe " + moyenne) ;
for (i=0, nbElSupMoy=0 ; i<nbEl ; i++ )
if (notes[i] > moyenne) nbElSupMoy++ ;
System.out.println (nbElSupMoy + " eleves ont plus de cette moyenne") ;
}
}

b) Affectation de tableaux
Java permet aussi de manipuler globalement des tableaux, par le biais d’affectations de leurs
références.
Considérons ces instructions qui créent deux tableaux d’entiers en plaçant leurs références
dans t1 et t2 :
int [] t1 = new int[3] ;
for (int i=0 ; i<3 ; i++) t1[i] = i ;
int [] t2 = new int[2] ;
for (int i=0 ; i<2 ; i++) t2[i] = 10 + i ;
Exécutons maintenant l’affectation :
t1 = t2 ; // la reference contenue dans t2 est recopiee dans t1
Dorénavant, t1 et t2 désignent le même tableau. Ainsi, avec :
t1[1] = 5 ;
System.out.println (t2[1]) ;
on obtiendra l’affichage de la valeur 5, et non 11.
Il est très important de noter que l’affectation de références de tableaux n’entraîne aucune
recopie des valeurs des éléments du tableau. On retrouve exactement le même phénomène que
pour l’affectation d’objets.

M. GBOLOVI 19 Cours JAVA

  Il est possible d'utiliser des tableaux multidimensionnels (même syntaxe que le C)
int tab1[] = new int [3] ; /* syntaxes équivalentes */
int[] tab2 = new int [3] ;

int[] tab3 = {1, 2, 3 } ; /* initialisation */

int[][] tab4 = new int[3][8] ; /* multidimension */

Il est possible pour une méthode de préciser un type de retour "tableau" :
int[] methode(…) { … } ou int methode(…) [] { … }
La syntaxe pour accéder un élément d'un tableau est la même que pour le langage C. En
particulier les indices d'un tableau vont de zéro à la taille du tableau moins un.
int[] newTab(int dim) {
int[] tab = new int[dim] ;
for (int i ; i<dim ; i++ } tab[i] = i ;
return tab ;
}
…
int[] t = obj.newTab(15) ;

c) La taille d’un tableau : length

Tout tableau possède l'attribut length qui contient la dimension du tableau. De ce point de
vue un tableau multidimensionnel est considéré comme un tableau de tableaux, de tableaux.
void printTabDim1 (int[] tab) {
for (int i=0 ; i < tab.length ; i++ ) System.out.println(tab[i]) ;
}
void printTabDim2 (int[][] tab) {
for (int i=0 ; i < tab.length ; i++ )
for (int j=0 ; j < tab[i].length ; j++) System.out.println(tab[i][j]) ;
}

d) Exemple de tableau d’objets

Les éléments d’un tableau peuvent aussi être des objets.
class Point
{ public Point(int x, int y)
{ this.x = x ; this.y = y ;
}
public void affiche ()
{ System.out.println ("Point : " + x + ", " + y) ;
}
private int x, y ;
}
public class TabPoint
{ public static void main (String args[])
{ Point [] tp ;
A = new Point[3] ;
A[0] = new Point (1, 2) ;
A[1] = new Point (4, 5) ;
A[2] = new Point (8, 9) ;
for (int i=0 ; i<A.length ; i++)
A[i].affiche() ;
}
}

M. GBOLOVI 20 Cours JAVA

II. L’HERITAGE
En JAVA, il est possible de dériver une classe à partir d'une autre classe : la classe fille ainsi
créée (ou sous-classe, ou classe dérivée) hérite alors des caractéristiques de sa classe mère
(ou super-classe), tout en la spécialisant avec de nouvelles fonctionnalités.
Cette technique permet donc de développer de nouveaux outils en se fondant sur un certain
acquis, ce qui justifie le terme d’héritage. Comme on peut s’y attendre, il sera possible de
développer à partir d’une classe de base, autant de classes dérivées qu’on le désire. De même,
une classe dérivée pourra à son tour servir de classe de base pour une nouvelle classe dérivée
1)Principes généraux, le mot clé extends
 Toute classe dans Java est une sous classe de la classe Object (elle en hérite
directement ou indirectement et éventuellement implicitement).
 Une classe ne peut hériter directement que d'une seule classe : il n'y a pas d'héritage
multiple dans Java contrairement à C++. Cette caractéristique du langage permet de
supprimer de nombreux problèmes liés à l'héritage multiple et est compensée par la
notion d'interface que nous aborderons après. Une sous-classe peut redéfinir une ou
plusieurs des méthodes dont elle hérite. Bien entendu, elle peut aussi en définir de
nouvelles, ainsi que de nouveaux attributs.
 Le mot clé extends permet de décrire les relations d'héritage : pour créer une nouvelle
classe fille, il suffit de déclarer cette classe en faisant suivre son nom du mot clé extends
puis du nom de sa classe mère.
Voici un exemple classique de hiérarchie de classes.
class Felin {
boolean afaim = true ;
void parler() { }
void appeler() {
System.out.println("Le Félin est appelé") ;
if (afaim) parler() ;
}
}
final class Chat extends Felin {
String race ;
void parler() { System.out.println("miaou!"); }
}
final class Tigre extends Felin {
void parler() { System.out.println("Groar!"); }
void chasser() { … }
}
…
Tigre tigre = new Tigre() ;
tigre.chasser() ; // OK
tigre.appeler() ; // OK : méthode héritée de la classe Felin

Remarques :
 Les classes Chat et Tigre héritent de la classe Felin, ce qui signifie que les instances
de Chat et Tigre seront aussi des Félins. En particulier les deux classes filles héritent
de l'attribut afaim, et des méthodes parler() et appeler().
 On remarque dans chaque classe fille que la méthode parler() est redéfinie et que de
nouveaux attributs et méthodes sont définis (race, chasser()). Les attributs d'une classe
dérivée comprennent bien les attributs hérités ET des attributs propres (idem pour les
méthodes).

M. GBOLOVI 21 Cours JAVA

  Les classes Chat et Tigre ont été déclarées final : on ne pourra donc pas définir de
nouvelle classe héritant d'une de ces classes.
 La classe Felin n'a explicitement aucune classe mère. Elle hérite donc implicitement
de la classe Object. Object

Felin

Chat Tigre

Tigre tigre = new Tigre() ;

Felin felin ;
felin = tigre ; // OK : c'est une conversion implicite, en fait la classe Tigre héritant de Felin,
// tout Tigre est aussi un Felin
tigre = felin ; // Erreur à la compilation : Tous les félins ne sont pas des tigres
// => une conversion explicite est obligatoire
tigre = (tigre)felin ; // OK

 Une variable qui référence un objet d'une certaine classe peut référencer un objet de
n'importe laquelle de ses sous-classes (un objet membre d'une sous-classe est aussi
membre de la super-classe) : c'est le cas ici pour la variable qui référence un objet de
type Felin qui peut donc contenir la référence sur un Tigre.
 Il est possible d'interdire qu'une classe puisse être héritée : il suffit de déclarer cette
classe final.
 Il est possible d'interdire qu'une méthode soit redéfinie dans une sous-classe : il
suffit de déclarer cette méthode final.
Remarque
 Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa classe de base.
En Java, le constructeur de la classe dérivée doit prendre en charge l’intégralité de la
construction de l’objet. S’il est nécessaire d’initialiser certains champs de la classe de base et
qu’ils sont convenablement encapsulés, il faudra disposer de fonctions d’altération ou bien
recourir dans la plupart du temps à un constructeur de la classe de base. Pour ce faire, il est
toutefois impératif de respecter une règle imposée par Java : Si un constructeur d’une classe
dérivée appelle un constructeur d’une classe de base, il doit obligatoirement s’agir de la
première instruction du constructeur et ce dernier est désigné par le mot-clé super.
2)Accès à la super-classe d'une classe : super(…)
Le mot clé super permet d'accéder à la version non redéfinie des attributs et méthodes de la
super-classe. Il permet aussi, s'il est utilisé comme première instruction dans un constructeur,
d'appeler un des constructeurs de la classe mère, avec ou sans paramètres.

class Mere {
int attribut ;
Mere() { attribut = 1 ; }
Mere(int attribut) ( this.attribut = attribut ; }
void print() { System.out.println("base" + attribut) ; }
}
class fille extends Mere {
boolean flag ;

M. GBOLOVI 22 Cours JAVA

 Fille( int a ) { super(a) ;
flag = true ;
}
void print() { super.print() ;
System.out.println("dérivée") ;
}
}
…
Fille f = new Fille(2) ;
Mere m = f ;
m.print() ;
// Affiche :
dérivée
base 2

III. Le Polymorphisme
Une méthode polymorphe est une méthode déclarée dans une super-classe et redéfinie par une
sous-classe. Dans Java, toute méthode est par défaut polymorphe.
Les méthodes final ne peuvent être redéfinies et ne sont donc pas polymorphes (définir une
méthode final est utile pour optimiser le byte code et pour des raisons de sécurité).
Il s’agit d’un concept extrêmement puissant en P.O.O., qui complète l’héritage. On peut
caractériser le polymorphisme en disant qu’il permet de manipuler des objets sans en
connaître (tout à fait) le type.
D’une manière générale, Java permet d’affecter à une variable objet non seulement la
référence à un objet du type correspondant, mais aussi une référence à un objet d’un type
dérivé. On peut dire qu’on est en présence d’une conversion implicite (légale) d’une référence
à un type classe T en une référence à un type ascendant de T ; on parle aussi de compatibilité
par affectation entre un type classe et un type ascendant.

class Zoo {
int MAX = 10 ;
Felin[] liste ;
int compteur = 0 ;
Cirque( int taille ) { MAX = taille ; liste = new Felin[MAX] }
void addFelin( Felin newfelin) {
if (compteur < MAX) liste[compteur++] = newfelin ;
else /* traitement d'erreur */
}
final void appeler() { // cette méthode ne peut être redéfinie dans une sous-classe
for ( int i=0 ; i<compteur ; i++ ) liste[i].parler() ; // appel polymorphe
}
}....
Zoo zoo = new Zoo(10) ;
zoo.addFelin(new Tigre()) ;
zoo.addFelin(new Chat()) ;
…
zoo.appeler() ;
…
En résumé, le polymorphisme en Java se traduit par :
• la compatibilité par affectation entre un type classe et un type ascendant,
• la ligature dynamique des méthodes.

M. GBOLOVI 23 Cours JAVA

class Point
{ public Point (int x, int y)
{ this.x = x ; this.y = y ;
}
public void deplace (int dx, int dy)
{ x += dx ; y += dy ;
}
public void affiche ()
{ System.out.println ("Je suis en " + x + " " + y) ;
}
private int x, y ;
}
class Pointcol extends Point
{ public Pointcol (int x, int y, byte couleur)
{ super (x, y) ; // obligatoirement comme premiere instruction
this.couleur = couleur ;
}
public void affiche ()
{ super.affiche() ;
System.out.println (" et ma couleur est : " + couleur) ;
}
private byte couleur ;
}
public class Poly
{ public static void main (String args[])
{ Point p []= new Point[3] ;
p [0]= new Point (3, 5) ;
p [2]= new Point (4, 8) ;
p.affiche() ; // appelle affiche de Point
p [1]= new Pointcol (4, 8, (byte)2) ;
for(int i=0 ;i<tab.length;i++) p[i].affiche();
}
}

IV. Méthodes et classes abstraites : abstract

a) Les classes abstraites

Prenons le cas d’une classe animal crée pour servir dans l’héritage pour créer des classes des
animaux comme Chat,Chien,Loup… mais cela n'a pas de sens de créer des objets Animal. Il
faut donc empêcher l'instanciation de la classe Animal.
Pour cela il suffit de déclarer la classe Animal abstract.
abstract public class Animal {
...
}
Dès lors le compilateur interdira de créer une instance de ce type. Il reste cependant possible
d'utiliser des classes abstraites comme superclasse ou avec le polymorphisme.
Une classe abstraite est une classe dont la définition est précédée du mot clé abstract. Une
classe abstraite ne peut jamais être directement instanciée avec l'opérateur new pour créer un
nouvel objet : seules des classes filles non abstraites peuvent l'être. Lorsqu'une classe possède
une ou plusieurs méthodes abstraites, elle doit elle-même être déclarée abstraite, mais la

M. GBOLOVI 24 Cours JAVA

réciproque n'est pas vraie : une classe peut être abstraite sans pour autant posséder de méthode
abstraite. Une classe héritant d'une classe abstraite doit donner une implémentation à toutes
les méthodes abstraites de sa super-classe. Si ce n'est pas le cas, elle doit aussi être déclarée
abstraite.
abstract class Felin {
boolean afaim = true ;
abstract void parler( ) ;
void appeler() {
System.out.println("Le Félin est appelé") ;
if (afaim) parler() ; }
}
class Tigre extends Felin {
void parler() { System.out.println("Groar!"); }
}

b) Les méthodes abstraites

Une méthode abstraite est une méthode dont on donne le prototype, sans en décrire
l'implémentation (sans définir les instructions qui décrivent ses actions). Elle doit de plus être
précédée du mot clé abstract. Une méthode abstraite doit obligatoirement être redéfinie dans
une sous-classe pour pouvoir être utilisée (par polymorphisme).
Deux points importants :
 Une méthode abstraite n'a pas de corps !
 Une méthode abstraite est toujours contenue dans une classe abstraite.
Une classe abstraite peut contenir à la fois des méthodes abstraites et concrètes.
Exemple : Soit Animal une classe abstraite contenant deux méthodes abstraites manger() et
vagabonder(). Soit Canin une classe abstraite étendant (i.e. héritant de) Animal et Chien une
classe concrète.
Alors Canin peut très bien implémenter vagabonder(). Et il reste donc à implémenter dans
Chien la méthode manger(). Ainsi, dans Chien, toutes les méthodes abstraites ont été
implémentées.

Exemples de classes abstraites

Nous voulons pouvoir stocker des chiens et des chats dans un tableau :
public class MesAnimaux {
private Animal [] animaux = new Animal [5];
private int indiceSuivant = 0;
public void add ( Animal a) {
if ( indiceSuivant < animaux . length ) {
animaux [ indiceSuivant ] = a;
indiceSuivant ++;
}
}
}
public TestMesAnimaux {
public static void main ( String [] args ) {
MesAnimaux list = new MesAnimaux ();
Chien c = new Chien ();
Chat d = new Chat ();
list .add(c);
list .add(d);
}

M. GBOLOVI 25 Cours JAVA

V. LES INTERFACES
Une interface est une déclaration permettant de décrire un ensemble de méthodes abstraites et
de constantes. On peut considérer une interface comme étant une classe abstraite ne contenant
que des méthodes abstraites et que des attributs final et static.

1)Définitions, les mots clés interface et implements.

Il est donc impossible d'instancier directement une interface. Par contre, une classe peut
implémenter une ou plusieurs interfaces, en utilisant le mot clé implements suivi du nom de
chaque interface concernée. Cette classe doit alors fournir une version pour chaque méthode
déclarée dans les interfaces implémentées.
On peut considérer l'implémentation des interfaces comme une forme d'héritage multiple
léger.
Une interface est définie de manière similaire à une classe, mais est caractérisée par le mot clé
interface.
interface Printable {
void print() ;
}

class Point extends Object implements Printable {

private double x,y ;…
void print() {
System.out.println( "(" + x + "," + ")" ) ; }}
Les attributs déclarés dans une interface sont obligatoirement des constantes statiques : les
mots clés static et final ne sont pas nécessaires pour le préciser. Ces attributs doivent donc
obligatoirement être initialisés.
interface Interval {
int MIN = 0 ;
int MAX = 1000 ;
} …
for (int i = Interval.MIN ; i < Interval.MAX ; i++ ) { … }
…
Par essence, les méthodes d’une interface sont abstraites et publiques. Néanmoins, il n’est pas
nécessaire de mentionner les mots-clés public et abstract .

M. GBOLOVI 26 Cours JAVA

 CHAPITRE 3 : LES PACKAGES ET LES
EXCEPTIONS

VI. LES PACKAGES

La notion de paquetage correspond à un regroupement logique sous un identificateur
commun d’un ensemble de classes. Elle facilite le développement et la cohabitation de
logiciels conséquents en permettant de répartir les classes correspondantes dans différents
paquetages. Le risque de créer deux classes de même nom se trouve alors limité aux seules
classes d’un même paquetage.
1)Les packages
Un package peut être considéré comme une bibliothèque de classes : Il permet de regrouper
un certain nombre de classes qui sont proches dans une seule famille et ainsi d'apporter un
niveau de hiérarchisation supplémentaire au langage.
Les packages sont eux-mêmes organisés hiérarchiquement. : on peut définir des sous-
packages, des sous-sous-packages, …
java

util lang awt

Date String
… Thread event Button
… List
ActionEvent …
ActionEvent
…
Dans cet exemple :
 La classe Button appartient au package java.awt (sous-package du package java)
 La classe ActionEvent appartient au package java.awt.event
Il y a deux manières d'utiliser une classe stockée dans un package :
 En utilisant le nom du package suivi du nom de la classe
java.util.Date now = new java.util.Date() ;
System.out.println(now) ;

 En utilisant le mot clé import pour importer (inclure) le package auquel appartient la
classe
import java.util.Date ; // Doit être en tête du fichier !!
… // Ne permet d'importer que la classe Date de java.util
Date now = new Date() ;
System.out.println(now) ;

M. GBOLOVI 27 Cours JAVA

 import java.util.* ; // Permet d'importer toutes les classes de java.util
…
Date now = new Date() ;
System.out.println(now) ;

On peut généralement utiliser l'une ou l'autre de ces deux méthodes, mais il existe un cas ou
l'on doit obligatoirement utiliser la première : si deux classes portant le même nom sont
définies dans deux packages différents.
Java importe automatiquement le package java.lang qui permet d'utiliser des classes comme
Thread ou System.
Remarque : System est une classe de java.lang, out est une variable statique de cette classe (de
type PrintStream) et println est une méthode de la classe PrintStream.
2)La structure de stockage des classes et des packages
Les fichiers sources Java ont pour extension .java, les fichiers compilés (donc contenant du
byte code) ont pour extension .class.
Seules les classes public sont accessibles d'un autre package, ou d'un autre fichier (les autres
classes ne sont pas connues en dehors de leur fichier). Il ne peut y avoir qu'une et une seule
classe public dans un fichier et cette classe doit porter le même nom que le fichier (en
respectant la casse).
Les fichiers des classes qui font partie d'un package doivent être placés dans une hiérarchie de
répertoires correspondant à la hiérarchie des packages. L’attribution d’un nom de paquetage
se fait au niveau du fichier source ; toutes les classes d’un même fichier source appartiendront
donc toujours à un même paquetage Ils doivent obligatoirement commencer par une
déclaration précisant le nom de leur package, précédé du mot clé package.
// Fichier Classe1.java dans le répertoire test/util/
package test.util ;
public class Classe1 {
public void test() { … } }

// fichier Appli1.java dans le sous répertoire application/

// la déclaration de package est inutile, puisque cette classe n'est pas destinée à être utilisée par d'autres
import test.util.* ;
public class Appli1 {
public static void main(String args[]) {
Classe1 c = new Classe1() ;
c.test() ;} }

3)Les principaux packages du JDK

java.applet Classes de base pour les Applets
java.awt Interface Utilisateur
java.io Entrées/Sorties, fichiers, …
java.lang Classes faisant partie du langage
java.math Utilitaires mathématiques
java.net Accès au réseau
java.security gestion de la sécurité
java.sql accès aux bases de données
java.util Conteneurs, dates, …
java.util.zip Pour compresser/décompresser

M. GBOLOVI 28 Cours JAVA

VII. LES EXCEPTIONS
1)Pourquoi des exceptions ?
Lorsque l'on examine le code source d'un programme écrit en langage C, on peut observer
qu'une grande partie de ce code est constitué de lignes d'instructions concernant la détection et
la gestion d'erreurs ou de traitement de cas exceptionnels (division par zéro, impossible
d'ouvrir un fichier, mauvaise saisie de données,…). Ces portions de code sont toujours
fortement imbriquées dans le reste du code et le programmeur a souvent des difficultés à
déterminer ce qu'il doit faire dans tel ou tel cas. Cela a plusieurs conséquences négatives :
 Le code est peu lisible, on ne distingue pas le traitement normal des traitements des
cas exceptionnels (qui ont souvent une logique très différente)
 Des traitements d'erreurs sont souvent oubliés par le programmeur.
 Il est souvent difficile de traiter de manière cohérente l'ensemble des erreurs :
comment distinguer un résultat valide d'un cas d'erreur ? (Par exemple si le code retour
d'une fonction est utilisé pour transmettre le résultat, où doit-on passer le code d'erreur
?)
C'est pourquoi des langages comme C++ ou Java ont introduit la notion d'exception : un
mécanisme facilitant le traitement de tous les cas exceptionnels et permettant en particulier de
séparer ces traitements des traitements habituels du programme.
Un cas exceptionnel est représenté par un objet (une exception), qui contient la description du
cas exceptionnel, et qui peut être transmis de l'endroit où il a été déclenché jusqu'à celui où
l'on sait le traiter (un gestionnaire d'exception).
Gestionnaire des
Traitement normal Exceptions :
: Exception X …
… …
… traitement de X
Erreur X
2)Représentation et déclenchement des exceptions :
classe Exception, opérateur throw
Une exception dans Java est un objet appartenant à une classe dérivée de la classe
java.lang.Exception.
Une exception est déclenchée avec le mot clé throw, après avoir créé le nouvel objet
Exception correspondant.
class MonException extends Exception { }
…
if ( erreurDétectée ) throw new MonException();
…

3)Propagation, Capture et traitement des exceptions

Lorsqu'une exception est déclenchée dans une méthode (soit directement avec throw, soit
parce qu’une méthode appelée dans cette méthode la déclenche et la propage) il y a deux
possibilités :
 On ne traite pas l'exception localement et on la propage.
 On traite l'exception localement.
a) Propagation des exceptions : le mot clé throws

M. GBOLOVI 29 Cours JAVA

Toute méthode susceptible de déclencher une exception qu’elle ne traite pas localement doit
mentionner son type dans une clause throws figurant dans son en-tête.
Ainsi toute exception pouvant être propagée par une méthode doit être signalée dans la
déclaration de celle-ci. Pour cela on utilise le mot clé throws suivi de la liste des exceptions.
class PasDeSolution extends Exception {}

class Equation { /* Equation du second degré ax2+bx+c */

private double a, b, c ;
public Equation(double a, double b, double c) { this.a = a ; this.b = b ; this.c = c ; }

public double resultat() throws PasDeSolution { // Cette méthode propage une exception
double discriminent = b*b-4*a*c ;
if (discriminent < 0) throw new PasDeSolution() ;
return ( b + Math.sqrt(discriminent) ) / (2 * a) ;
}
}

…
void calcul() throws PasDeSolution {
Equation eq = new Equation(1,0,1) ;
Eq.resultat() ;
}
// Cette méthode doit déclarer la propagation de l'exception PasDeSolution que Eq.resultat() peut
// déclencher, car elle ne la traite pas localement.

b) Capture des exceptions : catch, try et finally

Un gestionnaire d'exception est défini en :

 Définissant quelles instructions sont surveillées par ce gestionnaire, en plaçant celles-
ci dans un bloc d'instructions préfixé par le mot clé try.
 Définissant un ou plusieurs blocs de traitement d'exception préfixés par le mot-clé
catch.
void calcul() {
try {
Equation eq = new Equation(1,0,1) ;
double resultat = Eq.resultat() ;
System.out.println("Resultat = " + resultat) ;
}
catch ( PasDeSolution e ) {
System.out.println("Pas de solutions") ;
}
}
Si l'appel à la méthode Eq.resultat() se passe mal, l'exécution du bloc try est immédiatement
arrêtée et le bloc catch correspondant est exécuté, puis on passe à la suite du programme.
Dans le cas contraire, les instructions du bloc catch ne seront jamais prises en compte.
Il est possible de capturer dans un seul bloc catch plusieurs exceptions, en capturant une
exception dont la classe est une classe mère de toutes les exceptions concernées :
try {
…
}
catch ( Exception e ) { /* permet de capturer tout type d'exception */
…
}
Il est aussi possible de mettre plusieurs bloc catch :

M. GBOLOVI 30 Cours JAVA

 try { …
}
catch ( IOException e ) { /* permet de capturer tout type d'exception d'entrée/sorties */
…
}
catch ( PasDeSolution e ) {
…
}
Il est possible de définir un bloc finally qui, contrairement au catch, n'est pas obligatoire, et
qui permet de spécifier du code qui sera exécuté dans tous les cas, qu'une exception survienne
ou pas. Ce code sera exécuté même si une instruction return est exécutée dans le catch ou le
try !
try { // Ouvrir un fichier
// Lire et écrire des données
}
catch ( IOException e ) { /* permet de capturer tout type d'exception d'entrée/sorties */
System.out.println(e) ;
return ;
}
finally {// Fermeture du fichier
} …// autres traitements sur les données lues…

Remarque : Nous constatons dans cet exemple qu'un objet Exception peut être directement
affiché avec la méthode System.out.println(). L'affichage consiste en une chaîne de caractères
expliquant la nature de cette exception.

M. GBOLOVI 31 Cours JAVA

 CHAPITRE 4 : INTERFACE GRAPHIQUE
AVEC SWING

Introduction
Au début on utilisait le package AWT pour créer des interfaces graphiques. AWT
utilise directement les composants du système. Cela permet d'être rapide puisque
c'est le système qui s'occupe de la création. Néanmoins, Java se voulant portable,
on est obligé de limiter les composants AWT aux composants qu'on trouve sur tous
les systèmes d'exploitation. C'est pour pallier à ce manque de composants que
Swing a été introduit dans Java 1.2. Cette fois, les composants sont entièrement
dessinés en Java, on peut donc créer autant de composants que l'on veut. C'est
grâce à cela qu'on peut trouver maintenant un tableau ou un arbre dans les
interfaces graphiques en Java. On peut noter que tous les composants Swing
(reconnaissables à leur nom préfixés par J) héritent des composants AWT.

1) Les conteneurs
Les conteneurs contiennent d’autres objets qui peuvent être eux-mêmes des
conteneurs. Ils sont responsables de la disposition des objets qu'ils délèguent à un
gestionnaire de disposition (LayoutManager). La classe de base des conteneurs est
Container qui dérive de Component. Les conteneurs sont aussi des composants. En
tant que tels, ils vous laissent interagir avec eux, c'est-à-dire définir leurs propriétés,
appeler leurs méthodes et répondre à leurs événements.
 JWindow : C'est la fenêtre la plus basique. C'est juste un conteneur que vous
pouvez afficher sur votre écran. Il n'a pas de barre de titre, pas de boutons de
fermeture/redimensionnement et n'est pas redimensionnable par défaut.
 JDialog : C'est une fenêtre destinée aux boîtes de dialogue. Ce type de fenêtre
peut être modal, c'est-à-dire qu'elle bloque une autre fenêtre tant qu'elle est
ouverte. Elles sont destinées à travailler de paire avec la fenêtre principale.
 JFrame : C'est une fenêtre destinée à être la fenêtre principale de votre
application. Elle n'est dépendante d'aucune autre fenêtre et ne peut pas être
modale. Elle a une barre de titre et peut accueillir une barre de menu. Elle possède
un bouton de fermeture, un bouton de redimensionnement et un bouton pour
l'iconifier.
 JPanel pour contenir des composants.
 JApplet pour les applets.

import javax.swing.JFrame;
public class SimpleFenetre extends JFrame{
public SimpleFenetre(){
super();
build();//On initialise notre fenêtre
}
private void build(){
setTitle("Ma première fenêtre"); //On donne un titre à l'application
setSize(320,240); //On donne une taille à notre fenêtre

M. GBOLOVI 32 Cours JAVA

setLocationRelativeTo(null); //On centre la fenêtre sur l'écran
setResizable(false); //On interdit le redimensionnement de la fenêtre
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); //On dit à l'application de se
fermer //lors du clic sur la croix
}}

2) Les composants
1) Les composants atomiques
La classe JComponent est une classe abstraite dérivée de la classe Container qui
encapsule les composants atomiques d'une interface graphique. Les principaux
composants atomiques offerts par Java sont les boutons, les cases à cocher, les
boutons radio, les étiquettes, les champs de texte, les boîtes de liste et les boîtes de
liste combinée.
Exemples
class MaFenetre extends JFrame {
private Jlabel MonTexte;
private JTextField MonChamp1 ;
public MaFenetre () {
super("Une fenetre avec une etiquette") ;
setBounds(10,40,300,200) ;
MonTexte = new Jlabel ("texte initial");
//création d’une étiquette de référence MonTexte contenant le texte texte initial
getContentPane().add(MonTexte) ;
MonTexte.setText("nouveau texte") ;
//modification du texte de l’étiquette de référence MonTexte
MonChamp1 = new JtextField(20) ;
getContentPane().add(MonChamp1) ;
}
}
2) Les menus et les barres d'outils
Une fenêtre de type JFrame est composée de composants atomiques, mais aussi de
composants qui lui sont propres comme les menus et les barres d'outils.

Import java.awt.* ;
import javax.swing.* ;
class MaFenetre extends JFrame {
private JMenuBar barreMenus ;
private JMenu couleur, dimensions ;
private JMenuItem rouge, vert, hauteur, largeur ;
public MaFenetre () {
super("Une fenetre avec un menu") ;
setSize(300, 200) ;
//création d'une barre de menu
barreMenus = new JMenuBar() ;
setJMenuBar(barreMenus) ;
//ajout de la barre de menu dans la fenêtre
//création d'un menu Couleur et de ses options Rouge et Vert
couleur = new JMenu("Couleur") ;

M. GBOLOVI 33 Cours JAVA

barreMenus.add(couleur) ;
rouge = new JMenuItem("Rouge") ;
couleur.add(rouge) ;
couleur.addSeparator() ;
//ajout d'une barre séparatrice avant l'option suivante
vert = new JMenuItem("Vert") ;
couleur.add(vert) ;
//création d'un menu Dimensions et de ses options Hauteur et Largeur
dimensions = new JMenu("Dimensions") ;
barreMenus.add(dimensions) ;
hauteur = new JMenuItem("Hauteur") ;
dimensions.add(hauteur) ;
dimensions.addSeparator() ;
largeur = new JMenuItem("Largeur") ;
dimensions.add(largeur) ;
}}
public class MonMenu {
public static void main(String args[]) {
JFrame fen = new MaFenetre() ;
fen.setVisible(true) ;
}}

3) Les gestionnaires de disposition

Il existe de nombreux gestionnaires de layout dans Swing, en voici quelques uns :
 FlowLayout : C'est le layout par défaut des panels dans Swing. Il place les
composants sur une ligne et recommence une nouvelle ligne à chaque fois qu'il
atteint la fin de la ligne.
 BorderLayout : Ce layout place les composants dans 5 zones du container : La
zone du haut, la zone du bas, la zone de gauche, celle de droite et la zone du
centre. Il est très utile pour gérer le positionnement du contentpane.
 CardLayout : Ce layout place les composants sur des couches disposées les
unes sur les autres. On ne peut voir qu'une couche à la fois. On utilise surtout ce
layout quand on a une série de composants qui s'affichent en fonction de quelques
choses (liste déroulante, boutons, ...).
 GridLayout : Ce composant place les composants dans une grille. Il va
redimensionner les composants pour les rendre tous de la même taille. C'est
surtout utile quand on a plusieurs boutons ou champs texte en colonne et ligne qui
doivent avoir la même taille, par exemple, les boutons d'une calculatrice.
 GridBagLayout : C'est le layout le plus avancé et le plus puissant. Néanmoins,
c'est également le plus complexe à utiliser. Il permet de positionner les composants
dans une grille et il permet d'indiquer beaucoup de données pour indiquer comment
placer tel composant dans la grille.
Il y a encore d'autres layouts dans Java et on peut également en trouver d'autres
sur Internet.

class MaFenetre extends JFrame {

public MaFenetre () {

M. GBOLOVI 34 Cours JAVA

super("Une fenetre") ; setSize(300, 200) ;
Container contenu = getContentPane() ;
contenu.setLayout(new FlowLayout()) ;
//changement de gestionnaire de mise en forme
contenu.add(new JButton("UN")) ;
contenu.add(new JButton("DEUX")) ;
}
}

import java.awt.* ;
import javax.swing.* ;
class MaFenetre extends JFrame {
public MaFenetre () {
super("Une fenetre") ; setSize(300, 200) ;
Container contenu = getContentPane() ;
contenu.setLayout(new BorderLayout()) ; //inutile
contenu.add(new JButton("UN")) ;
//bouton placé au centre par défaut
contenu.add(new JButton("DEUX"), "North") ;
contenu.add(new JButton("TROIS"), "South") ;
contenu.add(new JButton("QUATRE"), "West") ;
contenu.add(new JButton("CINQ"), "East") ;
}
}
public class MonProgBLayout {
public static void main(String args[]) {
JFrame fen = new MaFenetre() ;
fen.setVisible(true) ;
}
}

4) La gestion des événements

Un clic souris, la frappe d’une touche au clavier ou le changement de la taille d’une
fenêtre sont des exemples d’événements.
Java classe les événements en deux niveaux : les événements de bas niveau (par
exemple, un clic dans une fenêtre) et les événements de haut niveau (par exemple,
une action sur un bouton qui peut provenir d’un clic souris ou d’une frappe au
clavier).
En Java, les événements n’ont pas une valeur physique, mais logique. Un
événement dépend du composant qui l’a généré.
On appelle source d’un événement l’objet qui l’a généré.
Exemple
L’événement émis suite à un clic souris dans une fenêtre est de type MouseEvent. .
L’événement émis suite à un clic souris sur un bouton est de type ActionEvent. .. .
Tout événement qui peut se produire dans une interface graphique est de type
XXXEvent, classe du paquetage java.awt.event ou du paquetage javax.swing.event
dérivée de la classe EventObject (classe du paquetage java.util dérivée de la classe
Object). ..

M. GBOLOVI 35 Cours JAVA

 1) Traiter un événement
Un composant ne traite pas forcément lui même les événements qu’il génère. Il
délègue ce traitement à des objets particuliers appelés écouteurs (un composant
peut être son propre écouteur).
En fonction des événements qu’ils traitent, un écouteur doit implémenter une
interface particulière, dérivée de l’interface EventListener, qui correspond à une
catégorie d’événements.
Pour traiter un événement de type XXXEvent, un écouteur doit implémenter
l’interface XXXListener.
Exemple
L’interface MouseListener correspond à une catégorie d’événements souris de type
MouseEvent. Elle comporte cinq méthodes correspondant chacune à un événement
souris particulier..
public interface MouseListener extends EventListener {
public void mousePressed(MouseEvent e) ;
//appelé lorsqu’un bouton de la souris est pressé sur un composant
//l’argument e de type MouseEvent correspond à l’objet événement généré
public void mouseReleased(MouseEvent e) ;
//appelé lorsqu’un bouton de la souris est relâché sur un composant
public void mouseClicked(MouseEvent e) ;
//appelé lors d’un clic souris sur un composant (la souris n’a pas été déplacée entre
//l’appui et le relâchement du bouton)
public void mouseEntered(MouseEvent e) ;
//appelé lorsque la souris passe de l’extérieur à l’intérieur d’un composant
public void mouseExited(MouseEvent e) ; }
//appelé lorsque la souris sort d’un composant (la souris passe de l’intérieur à
//l’extérieur du composant)
2) Intercepter un événement
Lorsqu’un composant veut intercepter un événement de type XXXEvent, il doit le
préciser dans son constructeur en appelant la méthode
addXXXListener(XXXListener objetEcouteur), où l’argument objetEcouteur
correspond à l’objet écouteur chargé de traiter l’événement.
Pour savoir quels événements sont susceptibles d’être générés par un composant
donné, il faut rechercher toutes les méthodes de la forme addXXXListener définies
dans la classe du composant et dans ses classes ascendantes.
Exemple
La classe Component définit notamment les méthodes suivantes :
public void addFocusListener(FocusListener l) ;
//prise et perte du focus (à un moment donné, un seul composant est sélectionné, on
//dit qu’il a le focus)
public void addKeyListener(KeyListener l) ;
//événements clavier
public void addMouseListener(MouseListener l) ;
//événements souris
public void addMouseMotionListener
(MouseMotionListener l) ;
//événements liés au déplacement de la souris

Exemple : Première version

M. GBOLOVI 36 Cours JAVA

import java.awt.* ; import java.awt.event.* ;
import javax.swing.* ; import javax.swing.event.* ;
class MaFenetre extends JFrame {
public MaFenetre () {
super("Une fenetre qui traite les clics souris") ;
setSize(300, 200) ;
addMouseListener(new EcouteurSouris());
//la fenêtre fait appel à un écouteur d’événements souris pour traiter les clics souris
}
}
//L’écouteur d’événements souris doit implémenter l’interface MouseListener qui
//correspond à une catégorie d’événements souris.
class EcouteurSouris implements MouseListener {
//redéfinition de la méthode appelée lors d’un clic souris
public void mouseClicked(MouseEvent e) {
System.out.println("clic dans la fenetre"); }
//la redéfinition des autres méthodes est "vide"
public void mousePressed(MouseEvent e) { }
public void mouseReleased(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
}
public class MonProgEvtClic1 {
public static void main(String args[]) {
JFrame fen = new MaFenetre() ;
fen.setVisible(true) ; }
}

Deuxième version
import java.awt.* ; import java.awt.event.* ;
import javax.swing.* ; import javax.swing.event.* ;
class MaFenetre extends JFrame implements
MouseListener {
public MaFenetre () {
super("Une fenetre qui traite les clics souris") ;
setSize(300, 200) ;
addMouseListener(this);
//la fenêtre est son propre écouteur d’événements souris
}
//L’argument e de type MouseEvent correspond à l’objet événement généré dans la
fenêtre //lors d’un clic souris. On peut utiliser les informations qui lui sont associées.
public void mouseClicked(MouseEvent e) {
int x = e.getX() ;
int y = e.getY() ;
//coordonnées du curseur de la souris au moment du clic
System.out.println("clic dans la fenetre au point de coordonnees " + x + ", " + y);
}
public void mousePressed(MouseEvent e) { }

M. GBOLOVI 37 Cours JAVA

public void mouseReleased(MouseEvent e) { }
public void mouseEntered(MouseEvent e) { }
public void mouseExited(MouseEvent e) { }
}
public class MonProgEvtClic2 {
public static void main(String args[]) {
JFrame fen = new MaFenetre() ;
fen.setVisible(true) ;
}
}
3) La notion d’adaptateur
Pour chaque interface XXXListener possédant plusieurs méthodes, Java fournit une
classe particulière XXXAdapter, appelée adaptateur, qui implémente toutes les
méthodes de l’interface avec un corps vide.
Pour définir un écouteur d’événements de type XXXEvent, il suffit alors de dériver
l'écouteur de la classe XXXAdapter et de redéfinir uniquement les méthodes voulues.
Exemple
class MaFenetre extends JFrame {
public MaFenetre () {
super("Une fenetre qui traite les clics souris") ;
setSize(300, 200) ;
addMouseListener(new EcouteurSouris());
}
}
class EcouteurSouris extends MouseAdapter {
//redéfinition uniquement de la méthode appelée lors d’un clic souris
public void mouseClicked(MouseEvent e) {
System.out.println("clic dans la fenetre") ;
}
}

4) Les boîtes de message et Les boîtes de

confirmation

a) Les boîtes de message

Une boîte de message fournit à l'utilisateur un message qui reste affiché tant que l'utilisateur
n'agit pas sur le bouton OK. Elle est construite à l'aide de la méthode de classe
showMessageDialog de la classe JOptionPane.
Exemple
import java.awt.* ;
import javax.swing.* ;
class MaFenetre extends JFrame {
public MaFenetre () {
super("Une fenetre") ; setSize(300, 200) ; }
}
public class BoiteMess {

M. GBOLOVI 38 Cours JAVA

public static void main(String args[]) {
JFrame fen = new MaFenetre() ;
fen.setVisible(true) ;
JOptionPane.showMessageDialog(fen, "Bonjour") ;
/*le premier argument de la méthode showMessageDialog correspond à la fenêtre parent de la
boîte de message, c'est à dire la fenêtre dans laquelle la boîte de message va s'afficher. Cet
argument peut prendre la valeur null.*/
}
}
Dans l'exemple précédent, nous n'avons défini que le contenu du message. Il existe une
variante de la méthode showMessageDialog qui permet aussi de choisir le titre de la boîte et
le type d'icône parmi la liste suivante (les paramètres sont des constantes entières de la classe
JOptionPane).
Paramètre Type d'icône
JOptionPane.ERROR_MESSAGE Erreur
JOptionPane.INFORMATION_MESSAGE Information
JOptionPane.WARNING_MESSAGE Avertissement
JOptionPane.QUESTION_MESSAGE Question
JOptionPane.PLAIN_MESSAGE Aucune icône
Exemple
JOptionPane.showMessageDialog(fen, "Mauvais choix", "Message d'avertissement",
JOptionPane.ERROR_MESSAGE) ;

b) Les boîtes de confirmation

Une boîte de confirmation offre à l'utilisateur un choix de type oui/non. Elle est construite à
l'aide de la méthode de classe showConfirmDialog de la classe JOptionPane.
Exemple
import java.awt.* ;
import javax.swing.* ;
class MaFenetre extends JFrame {
public MaFenetre () {
super("Une fenetre") ; setSize(300, 200) ; }
}
public class BoiteConf {
public static void main(String args[]) {
JFrame fen = new MaFenetre() ;
fen.setVisible(true) ;
JOptionPane.showConfirmDialog(fen, "Voulez-vous continuer ?") ;
}
}

M. GBOLOVI 39 Cours JAVA

Dans l'exemple précédent, nous n'avons défini que la question posée à l'utilisateur. Il existe
une variante de la méthode showConfirmDialog qui permet aussi de choisir le titre de la boîte
et la nature des boutons qui s'y trouvent parmi la liste suivante (les paramètres sont des
constantes entières de la classe JOptionPane).
Paramètre Type de boîte

JOptionPane.DEFAULT_OPTION (-1) Erreur

JOptionPane.YES_NO_OPTION (0) boutons YES et NO
JOptionPane.YES_NO_CANCEL_OPTION(1)boutons YES,NO et CANCEL
JOptionPane.OK_CANCEL_OPTION (2) boutons OK et CANCEL

M. GBOLOVI 40 Cours JAVA

 CHAPITRE 5: LE RESEAU

Ce chapitre concerne les classes du package java.net qui permettent de travailler avec le
réseau au niveau applicatif. Depuis son origine, Java fournit plusieurs classes et interfaces
destinées à faciliter l'utilisation du réseau par programmation.
Le modèle OSI (Open System Interconnection) propose un découpage en sept couches des
différents composants qui permettent la communication sur un réseau.

Le protocole IP est un protocole de niveau réseau qui permet d'échanger des paquets d'octets
appelés datagrammes. La couche de transport est implémentée dans les protocoles UDP ou
TCP.
Le système des sockets est le moyen de communication inter−processus développé pour
l'Unix Berkeley (BSD). Il est actuellement implémenté sur tous les systèmes d'exploitation
utilisant TCP/IP. Un socket est le point de communication par lequel un thread peut émettre
ou recevoir des informations et ainsi elle permet la communication entre deux applications à
travers le réseau.
La communication se fait sur un port particulier de la machine. Le port est une entité logique
qui permet d'associer un service particulier à une connexion. Un port est identifié par un entier
de 1 à 65535. Par convention les 1024 premiers sont réservés pour des services standards (80 :
HTTP, 21 : FTP, 25: SMTP, ...)
Java prend en charge deux protocoles : TCP et UDP.
Les classes et interfaces utiles au développement réseau sont regroupés dans le package
java.net.

1)Définitions
URL = Uniform Resource Locator
Une URL est une adresse qui permet de localiser une ressource sur un réseau.
Elle contient :
 Le protocole utilisé : http, ftp, file…
 Le nom du serveur ou son adresse IP avec éventuellement un port,
 Le chemin et le nom du fichier qui fournira les informations et
éventuellement des paramètres sous la forme clé=valeur.
http://www.atos-group.com/index.html
ftp://www.ibp.fr/pub/win3/outils/util.exe
file://<serveur>/<chemin>
Dans le cas d'un fichier local, l'URL est de la forme : file://<serveur>/<chemin>
Les classes Java ne supportent que les protocoles http, ftp et file.

M. GBOLOVI 41 Cours JAVA

 2)Les classes URL et URLConnection
La classe URL permet de représenter une adresse. Cette classe fournit la méthode
openConnection() qui permet d'ouvrir une connexion réseau correspondant à cette
adresse. Cette méthode retourne un objet de type URLConnection.
La classe URLConnection permet de représenter une connexion à une ressource
distante : elle permet de récupérer un flux d'octet en entrée ou en sortie vers cette
ressource. (méthodes getInputStream() et getOutputStream()).

class WebTexte {
public static void main(String args[]) {
try {
URL u = new URL(args[0]) ;
URLConnection c = u.openConnection() ;
BufferedReader in =
new BufferedReader(new InputStreamReader(c.getInputStream()));
String inLine ;
while((inLine = in.readLine()) != null) System.out.println(inLine) ;
}
catch (IOException e) {
System.out.println(e) ;
}
}
}

3)Les sockets
Présentation
Les sockets sont un ensemble de classes permettant de travailler directement au niveau
des protocoles TCP/IP ou UDP/IP. L'utilisation de ces classes est proche de celle de la
bibliothèque de fonctions C correspondantes.
Ces classes permettent de définir son propre protocole de communication applicatif pour
faire communiquer deux applications sur le réseau.
Les classes à utiliser sont :
ServerSocket : pour se mettre à l'écoute d'une nouvelle connexion (coté
serveur).
Socket : pour établir et gérer une connexion TCP (coté serveur et client).
InetAddress : pour construire une adresse réseau (coté client).
DatagramSocket : pour gérer une connexion UDP.
Nous n'aborderons dans ce cours que la programmation du protocole TCP/IP (nous ne
verrons donc pas la classe DatagramSocket)
a) Le client : classes InetAddress et Socket
La classe InetAddress permet de construire et de représenter une adresse IP.
On ne peut pas directement construire un objet de cette classe, mais celle-ci offre
plusieurs méthodes statiques qui permettent de construire et récupérer la référence d'un
objet InetAddress :
static Inetaddress getByName(String nom) ; // à partir d'un nom de serveur
static InetAddress getLocalHost() ;// Pour l'adresse de la machine locale
InetAddress a1 = InetAddress.getByName("www.inria.fr") ;
InetAddress a2 = InetAddress.getByName("194.89.34.2") ;
InetAddress a3 = InetAddress.getLocalHost() ;
La classe Socket permet de créer et gérer une connexion TCP/IP vers un serveur distant
sur un port donné. Voici quelques méthodes :

M. GBOLOVI 42 Cours JAVA

 Socket(InetAddress adresse, int port) ;
InputStream getInputStream() ;
OutputStream getOutputStream() ;
void close();
int getPort() ; // retourne le port utilisé à distance
int getLocalPort() ; // retourne le port utilisé localement
InetAddress getInetAddress() ; // retourne l'adresse utilisée à distance
InetAddress getLocalAddress() ; // retourne l'adresse utilisée localement
import java.io.*
import java.net.*
public class Client {
private InetAddress adresse ;
private Socket sock ;
Client(String serveur) { try {
adresse = InetAddress.getByName(serveur) ;
sock = new Socket(adresse, 5000) ;
BufferedReader in = new BufferedReader(new InputStreamReader(sock.getInputStream())) ;
PrintWriter out = new PrintWriter( new OutputStreamWriter(sock.getOutputStream()),true);
// true permet de faire de l'auto-flush.
out.println("Bonjour Serveur de la part de : " + InetAddress.getLocalHost()) ;
System.out.println(in.readLine());
sock.close() ;
} catch (Exception e) { System.out.println(e) ; }
}
public static void main(String argv[]) { new Client( argv[0]) ; }
}

b) Le serveur : classes ServerSocket et Socket

Pour écrire un serveur, il est nécessaire de pouvoir se mettre à l'écoute de demandes de
connexion en provenance des clients.
C'est le rôle des instances de la classe ServerSocket : on construit une instance de cette classe
en lui fournissant le numéro du port sur lequel elle doit se mettre à l'écoute et il suffit alors
d'utiliser la méthode accept() sur l'objet construit pour se mettre en attente d'une connexion.
La méthode accept() est bloquante jusqu'à ce qu'une connexion se produise et elle renvoie alors
une référence sur un objet de type Socket pour gérer la nouvelle connexion.
La suite du code est alors similaire à ce qui se passe sur un client (utilisation de Socket).
import java.io.*
import java.net.*
public class Serveur {
private ServerSocket sock ;
private Socket client ;
Serveur() { try {
sock = new ServerSocket(5000) ;
while(true) {
client = sock.accept() ;
BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream())) ;
PrintWriter out = new PrintWriter( new OutputStreamWriter(client.getOutputStream()),true);
// true permet de faire de l'auto-flush.
System.out.println(in.readLine());
out.println("Bonjour Client de la part de " + InetAddress.getLocalHost() ) ;
client.close() ;
}
} catch (Exception e) { System.out.println(e) ; }
}
public static void main(String argv[]) { new Serveur( ) ; }
}

M. GBOLOVI 43 Cours JAVA

 Le serveur défini dans l'exemple précédent ne permet pas de traiter plus d'une requête à
la fois.
Pour pouvoir accepter plusieurs requêtes simultanément il est nécessaire d'utiliser un
Thread différent pour gérer la connexion de chaque nouvelle requête.
import java.io.*
import java.net.*
public class Serveur {
private ServerSocket sock ;
private Socket client ;
Serveur() { try {
sock = new ServerSocket(5000) ;
while(true) {
client = sock.accept() ;
Requete req = new Requete(client) ;
req.start() ;
}
} catch (Exception e) { System.out.println(e) ; }
}
public static void main(String argv[]) { new Serveur( ) ; }
}

import java.io.*
import java.net.*

public class Requete extends Thread {

private Socket sock ;

Requete(Socket sock) { this.sock = sock ; }

public void run() {

BufferedReader in =
new BufferedReader(new InputStreamReader(sock.getInputStream())) ;
PrintWriter out =
new PrintWriter( new OutputStreamWriter(sock.getOutputStream()),true);

String input = in.readLine();

if (input != null) {
System.out.println(input) ;
out.println("Bonjour Client de la part de " + InetAddress.getLocalHost() ) ;
}
}
}

M. GBOLOVI 44 Cours JAVA