Le langage JAVA - IPNL

Le langage JAVA
G. Baulieu Institut de Physique Nucléaire de Lyon – Septembre 2009

Quelques acronymes
●
●
●
●
●
JDK : Java Development Kit
SDK : Software Development Kit
J2SE : Java 2 Standard Edition
JRE : Java Runtime Environment
API : Application Programming Interface

Points forts
●
●
●
●
●
Simplicité : syntaxe ~C++ simplifié (pointeurs,
fichiers d'entête, surcharge des opérateurs...)
Orienté objet
Fiabilité : gestion de la mémoire, compilateur
puissant
Portabilité : executable sur plusieurs systèmes
Bibliothèque importante et documentée

Naissance de Java
Java est un langage très récent...
● 1991 : Projet Green (P. Naughton/J. Gosling – Sun)
Langage Oak
● 1996 : Java 1.0 – Premiere version officielle
● 2004 : JDK 1.5 "Java 5.0"
● 2006 : JDK 1.6 "Java 6.0"

La machine virtuelle
Code source
Compilation
Bytecode (pseudo­code)
Indépendant du
système
Interprétation
Machine Virtuelle
Génération
Dépendant du
système
Langage machine

Notions fondamentales
1. Premiers pas
1. Structure d'un programme
2. Compilation / Execution
3. Localisation des classes
2. Types de données
3. Déclaration de variables
4. Les tableaux
5. Les opérateurs
7. Les structures de contrôle
1. Conditions (IF)
2. Boucles (FOR, WHILE, DO...WHILE)
3. SWITCH
4. Interruption de boucle
8. Les méthodes
1. Généralités
2. La méthode "main"
6. Les conversions de type

1.1 Structure d'un programme
Fichier PremiereClasse.java
/*
Premier exemple de programme
*/
public class PremiereClasse
{
// Fonction principale
public static void main(String[] args)
{
System.out.println("Premier programme!");
}
}
Commentaires
entre /* et */
ou ligne précédée de //
Déclaration de
la classe
Fonction
principale

1.2 Compilation d'un programme
●
Le fichier doit porter le nom de la classe
Dans notre exemple : PremiereClasse.java
● Compilation :
$ javac PremiereClasse.java
Génère un fichier PremiereClasse.class
● Execution :
$ java PremiereClasse

1.3 Localisation des classes
●
●
Par défaut : uniquement le répertoire courant
Ajout de répertoires
– Par l'option ­classpath :
$ java ­classpath ./classes/ PremiereClasse
– Par la variable d'environnement CLASSPATH :
$ export CLASSPATH=./classes/
$ java PremiereClasse

2. Types de données
●
●
Java est un langage fortement typé
8 types primitifs:
– Entiers
byte 8 bits -128 à 127
short 16 bits -32 768 à 32 767
int 32 bits -2 147 483 648 à 2 147 483 647
-9 223 372 036 854 775 808
long 64 bits à
9 223 372 036 854 775 807

2. Types de données (2)
– Virgule flottante
float 32 bits 6 décimales significatives
double 64 bits 15 chiffres significatifs
– Le type char (16 bits)
Une unité de code UTF­16
– Le type boolean (1 bit)
Deux valeurs : true et false
Il n'existe pas de type chaîne de caractères. On utilisera la
classe String.

3. Déclaration de variable
●
Indication du type suivi du nom de la variable:
●
●
int compteur;
double aire;
La variable doit ensuite être initialisée:
compteur = 0;
aire = 3.54;
On peut déclarer et initialiser une variable dans la même
instruction:
int compteur = 0;
● Le mot clé final permet de déclarer une constante :
final int COMPTEUR = 0;

4. Les tableaux
●
●
Structure permettant de stocker une série de valeurs du même type.
Déclaration et initialisation:
int[] tab;
tab = new int[10];
­> déclare la variable tab et lui alloue l'espace mémoire pour 10
valeurs de type int.
Remarque : "int tab[]" est également valable.
●
Affectation:
tab[5] = 3;
­> Affecte la valeur 3 à la sixième case du tableau (l'indice commence à 0!).

4. Les tableaux (2)
● Lecture :
int i = tab[5];
­> La variable i contient la valeur de la sixième case du
tableau.
●
Raccourci:
int[] tab = {3,24,5,3,6,54,7,1,6,45};
­> Déclare, initialise et affecte les valeurs au tableau tab.

4. Les tableaux (3)
●
Taille du tableau:
int taille = tab.length;
●
Copie d'un tableau :
– Copie de la variable :
int[] secondArray = tab;
secondArray[0] = 33;//tab[0] vaut 33!!!
– Utilisation de la fonction arraycopy(from,fromIdx,to, toIdx, count)
int[] secondArray = new int[5];
System.arraycopy(tab, 0, secondArray, 0, 5);//copie les 5 premiers
éléments de tab dans secondArray – attention à la taille de
secondArray!
●
Tri d'un tableau :
int[] tab = {3,24,5,3,6,54,7,1,6,45};
java.util.Arrays.sort(tab);//tab contient maintenant
{1,3,3,5,6,6,7,24,45,54}

5. Opérateurs
● Affectation : =
● Addition, soustraction et multiplication : +, ­, *
● Division : /
– Si appelé avec 2 entiers : division entière
– Sinon division en virgule flottante
●
On peut combiner opérateurs arithmétiques et opérateurs
d'affectation : +=, ­=, *= ...
int n = 2;
n += 3; // n vaut 5

5. Opérateurs (2)
● Incrémentation, décrémentation : ++,­int
m = 1;
m++; //m vaut 2
int n = 2;
int a = 2 * ++m; //a vaut 6, m vaut 3
int b = 2 * n++; //b vaut 4, n vaut 3
● Opérateurs relationnels : ==, !=, >, =,

6. Conversions
●
●
Si besoin, les valeurs peuvent être converties
automatiquement :
int i = 123;
long l = i;
Attention : dans certains cas cela peut entraîner une perte
de précision:
– int vers float
– long vers float
– long vers double

6. Conversions (2)
● On peut faire une conversion explicite :
double d = 4.321;
int i = (int)d; // i vaut 4
Autre exemple :
int i=3;
double d1 = 5/i; // d1 vaut 1.0 !
double d2 = 5/(double)i; // d2 vaut 1.6667

7.1 Conditions ­ IF
●
Syntaxe de l'instruction conditionnelle:
if (condition) instruction
– La condition est une expression booléenne, indiquée entre
parenthèses.
– L'instruction peut être unique, ou on peut en placer plusieurs dans
un bloc d'instructions (instructions entre accolades).
●
Exemples
if(x

7.1 Conditions(2) ­ ELSE
●
●
●
Instruction else:
if (condition) instruction1 else instruction2
if(x

7.2 Les boucles ­ FOR
●
Boucle gérée par un compteur:
for(initialisation;test;mise à jour)
instruction(s);
● Exemple :
for (int i=0;i Affiche les valeurs de i de 0 à 9.

7.2 Les boucles (2) – FOR EACH
●
●
Simplification pour les tableaux et collections
Version classique ('tab' est un tableau de doubles):
for (int i=0;i

7.2 Les boucles (3) ­ WHILE
●
Boucle tant que la condition est vraie.
while(condition)
instruction(s);
● Exemple :
while(nbSucre

7.2 Les boucles (4) ­ DO...WHILE
●
Répète l'instruction jusqu'à ce que la condition soit vraie.
do
instuction(s);
while(condition);
Les instructions sont exécutées au moins une fois.
●
Exemple
do{
}
System.out.println("Saisir une valeur positive : ");
//affectation d'une valeur saisie par l'utilisateur
dans la variable double "reponse"
while(reponse

7.3 L'instruction SWITCH
●
Permet de gérer les différentes valeurs prisent par une
variable entière.
● Syntaxe :
switch(variable){
case 1:
}
...
break;
case 2:
...
break;
default:
...
break;

7.4 Interruption de boucle
●
L'instruction break permet de sortir immédiatement d'une
boucle.
●
L'instruction continue court circuite la fin de boucle.
while(true){
...
if(stop)
}
break;
...
if(shortcut)
continue;
...

7.4 Interruption de boucle (2)
●
On peut également sortir de boucles imbriquées en utilisant
un label:
label_name:
while(...){
...
while(...){
}
}
if(stop)
break label_name; // sort des boucles
...
... à utiliser avec parcimonie...

8.1 Les méthodes
●
Une méthode est une suite d'instructions permettant de
réaliser des traitements sur les données.
● Déclaration :
type_de_retour Nom(liste d'arguments){
Corps_de_la_méthode
return valeur_de_retour
}
int addition(int a, int b){
int resultat = a+b;
return resultat;
}
Si la méthode ne retourne rien, on utilise le type de retour void.
● Appel de la méthode :
int somme = addition(3,5);//somme vaut 8 après l'appel

8.2 La méthode main
●
●
●
Point d'entrée dans le programme (obligatoire!)
Prototype:
public static void main(String[] args)
{
...
}
Le tableau args contient les arguments passés dans la ligne de
commande :
1er argument : args[0]
2ème argument : args[1] ...

Programmation orientée objet
1. Introduction
1. Vocabulaire
2. Exemple : la classe Color
3. Utilisation des paquetages
4. La classe String
3. Ajouter une classe dans un paquetage
4. Documenter le code : JAVADOC
5. Les fichiers JAR
6. Un outil de construction : ANT
5. Les classes Integer, Double...
2. Création d'une classe
1. Les champs
2. Les constructeurs
3. Libération de la mémoire
4. Les méthodes
5. Le mot clé this
6. L'instruction static

1. Introduction
●
●
Décomposer le programme en modules indépendants : les
objets.
Chaque objet contient sa structure de données (les
champs) et les traitements possibles sur ces données (les
méthodes).
Modifier la structure des données ou
le traitement de celles­ci ne modifie
pas le programme général.

1.1 Vocabulaire
●
●
●
Une classe contient la description des données d'un objet
ainsi que les traitements pouvant être effectués sur celui­ci
(= le moule).
On peut ensuite créer une ou plusieurs "instance(s) de la
classe" (= les biscuits).
Les données de l'objet ne seront pas accessibles à
l'utilisateur : c'est l'encapsulation.
Si les données de l'objet sont incohérentes, l'erreur est
obligatoirement dans la classe! Nul besoin d'aller chercher
partout dans le programme...

1.2 Exemple : la classe Color
●
L'API java met à notre disposition la classe java.awt.Color
● Création d'une instance de la classe :
java.awt.Color maCouleur = new java.awt.Color(255,255,255);//Création
d'une instance contenant la couleur blanche

1.3 Interlude : Les paquetages
● But :
– Structurer les classes
– Faciliter la recherche d'une classe
– Eviter les confusions entre classes de même nom
– Modifier la visibilité d'une classe

1.3 L'instruction import
●
Permet de créer un raccourci pour faire référence aux
classes d'un paquetage:
import java.awt.Color;
class [...]{
[...]
Color maCouleur = new Color(255,255,255);
● On peut également utiliser :
import java.awt.*;
...pour pouvoir accéder à toutes les classes du paquetage
java.awt.

1.2 Exemple : la classe Color(2)
●
On peut créer différentes instances de la même classe:
Color blanc = new Color(255,255,255);
Color rouge = new Color(255,0,0);
Les 2 objets ont une existence propre!
●
On peut appeler différentes méthodes sur les objets:
int valeurRouge = rouge.getRed(); // valeurRouge vaut 255
Appel de la méthode getRed() appartenant à la classe Color
sur l'objet 'rouge'.

1.2 Exemple : la classe Color(3)
● Le programme suivant :
Color rouge = new Color(255,0,0);
System.out.println(rouge);
Color rougeSombre = rouge.darker();
System.out.println(rougeSombre);
● Affiche :
java.awt.Color[r=255,g=0,b=0]
java.awt.Color[r=178,g=0,b=0]
●
Comment connaître les méthodes d'une classe?
Grâce à la documentation de la classe!
http://java.sun.com/j2se/1.5.0/docs/api/

1.2 Exemple : la classe Color(4)

1.4 La classe String
● Déclaration :
String vide = new String(""); // ou String vide = "";
String exemple = "Chaine de caractères";
● Longueur :
int taille = exemple.length();
● Concaténation :
String nouvelleChaine = "Exemple d'une "+exemple;
● Sous chaines :
String petiteChaine = exemple.substring(0,7);
● Egalité :
boolean sontEgales = exemple.equals("test");

1.5 Classes Integer, Double...
Il est parfois utile de pouvoir utiliser les types de base comme des
objets. L'API Java dispose de classes wrapper:
Integer objectInt = new Integer(5);
La conversion est faite automatiquement :
int i = objectInt; //equivalent à objectInt.intValue()
Ces classes permettent aussi la conversion de chaines de
caractères :
int i = Integer.parseInt(“234”);

2. Création d'une classe
● Une classe est composée :
● De champs : données propres à l'objet.
● De constructeurs : méthodes permettant d'instancier un
objet (création de l'objet).
● De methodes : services offerts par la classe pour
manipuler l'objet.

2.1 Les champs de la classe
●
Ce sont les données qui seront contenues dans une
instance de la classe.
●
Déclaration:
class Personne{
private String nom;
private String prenom;
...
}

2.1 Les champs de la classe (2)
Portée des champs :
●
private indique que le champ n'est accessible que de l'intérieur
de la classe (encapsulation).
On pourrait (mais on ne le veut probablement pas!) déclarer les
champs:
●
●
public : toujours visible par tous.
protected : visible pour le paquetage et les classes filles (voire
héritage).
Les méthodes de la classe utilisent les mêmes modificateurs de
visibilité.

2.1 Les champs de la classe (3)
●
Initialisation explicite
On peut initialiser les champs de la classe au moment de la déclaration :
class Personne{
private String nom = "";
private String prenom = "";
...
}
Cette affectation est effectuée avant l'appel du constructeur.

2.2 Les constructeurs
●
Méthode permettant d'instancier un objet.
●
Le constructeur alloue la mémoire pour les champs de
l'objet et les initialise.
●
●
Le constructeur est une méthode ayant le même nom que la
classe :
public Personne(){
nom = "X";
prenom = "Toto";
}
Cette méthode est appelée lors de l'instruction:
Personne p = new Personne();

2.2 Les constructeurs (2)
●
Si aucun constructeur n'est défini, java crée un constructeur
par défaut (sans argument). Ce constructeur initialise les
champs de la classe :
– numérique : 0
– booléen : false
– classe : null (inexistant)
Pour des raisons de lisibilité, il est préférable d'écrire
explicitement un constructeur.

2.2 Les constructeurs (3)
●
On peut définir plusieurs constructeurs pour une même classe
(surcharge):
public Personne(){
nom = "X";
prenom = "Toto";
}
public Personne(String n, String p){
nom = n;
prenom = p;
}
● Appel :
Personne p1 = new Personne();// Toto X
Personne p2 = new Personne("Dupont", "Jean");// Jean Dupont

2.3 Libération de la mémoire
●
●
La libération de la mémoire est effectuée par java par
l'intermédiaire du ramasse­miettes (garbage collector).
Il n'y a donc pas de destructeurs.
●
Si une ressource doit absolument être libérée il faut
explicitement appeler une méthode écrite dans ce but.

2.4 Les méthodes de la classe
●
Fournissent des fonctionnalités à la classe.
●
Les méthodes seront appelées par une instance de la
classe :
Personne p = new Personne();
String nom = p.getNom();
● Implémentation :
public String getNom(){
return nom;
}

2.4 Les méthodes de la classe (2)
Les méthodes d'une classe ont accès aux champs privés de la
classe et peuvent donc les modifier.
public void setNom(String n){
}
nom = n;
Personne p = new Personne();
p.setNom("Dupont");//impossible si setNom etait private !
Rappel : une méthode peut être définie comme public, private ou
protected
Implémenter la méthode String toString() permet d'afficher l'objet avec
System.out.println();
Implémenter la méthode Object clone() permet de renvoyer une copie de
l'objet.

2.5 Le mot clé this
Fait référence à l'instance courante de la classe:
void setNom(String nom){
}
this.nom = nom;
Il peut également être utilisé pour appeler un constructeur
depuis un autre constructeur :
public Personne(){
}
this("Dupuis", "Paul"); // Premiere instruction!!
// Le constructeur Personne(String, String) est appelé

2.6 L'instruction static
●
●
●
Permet de définir des variables et méthodes de classe.
Une variable statique est commune à toutes les instances de la
classe.
Une méthode (ou une variable) statique peut être appelée sans
instance, avec le nom de la classe :
double r = Math.sqrt(81);// appel de la méthode statique sqrt()
de la classe Math.
●
Une méthode statique ne peut accéder qu'aux champs
statiques de la classe.

3. Ajouter une classe dans un
paquetage
● Syntaxe :
package Formation.Java.Exemples;
class MaClasse{...}
La classe MaClasse se trouve dans le paquetage
"Formation.java.Exemples" : le fichier MaClasse.class devra donc se
trouver dans le répertoire :
[...]/Formation/Java/Exemples/

4. Documenter le code : Javadoc
●
●
Outil permettant de générer de la documentation à partir du
code source.
Nécessite des commentaires dans le code:
Commentaires situés entre /** et */
●
Documentation d'une classe:
/** Commentaire décrivant la classe.
@version 1.0
@author Jules Dupont
*/
public class MaClasse {...}

4. Javadoc (2)
●
Documentation d'un méthode:
/** Commentaire décrivant la méthode.
@param a Description de l'argument a
@param b Description de l'argument b
@return Le résultat de la méthode
*/
public int addition(int a, int b){...}
●
Génération:
% javadoc ­author ­version ­d ./doc/ MaClasse.java

4. Javadoc (3)
http://java.sun.com/j2se/javadoc/

5. Créer une archive : les
fichiers JAR
●
●
●
Java ARchive
Permet de stocker tous les fichiers (.class, images, sons...)
dans un seul fichier.
Peut être compressé.
● Création de l'archive :
% jar cf NomArchive.jar Fichiers

5. Les fichiers JAR (2)
●
On peut ajouter un fichier MANIFEST.MF qui contient des
informations sur l'archive :
Manifest­Version: 1.0
Main­Class: Formation/MaClasse
●
Création de l'archive:
% jar cfm NomArchive.jar MANIFEST.MF Fichiers
● On peut alors lancer le programme par la commande :
% java ­jar NomArchive.jar

6. Un outils de construction :
ANT
●
●
●
Il est fastidieux de devoir taper de longues commandes à
chaque modification.
Dans un projet conséquent, il peut y avoir plusieurs
commandes à exécuter pour compiler, créer des archives,
générer la documentation, créer une distribution...
ANT (~make) permet de simplifier ces procédures en
définissant des taches pouvant dépendre les une des
autres.

6. Un outils de construction :
ANT (2)
– On défini des taches dans le fichier build.xml :
– On peut ensuite exécuter une tache avec la commande :
% ant nom_de_la_tache
Exemple : % ant compile

L'héritage
1. Introduction
1. Concept
2. Exemple
2. Syntaxe
6. Les interfaces
1. Utilisation
2. Création
7. Le clonage
1. Le mot clé extends
2. Les constructeurs
3. Les méthodes
4. Interdire l'héritage
3. Le polymorphisme
4. Classes et méthodes abstraites
5. La classe Object

1.1 Concept
●
●
●
L'idée est de pouvoir créer de nouvelles classes à partir de
classes existantes.
Exprime la relation "est un". Par exemple, un lion est un
animal : la classe 'Lion' peut donc hériter de la classe
'Animal'. Elle dispose ainsi automatiquement de toutes les
données et services de la classe 'Animal'.
La classe 'Animal' est appelée classe mère ou superclasse
et la classe 'Lion' classe fille ou sous­classe.

1.2 Exemple
Le lion et l'oiseau sont des animaux : ils ont une taille, une couleur,
peuvent manger et dormir.
Seul le lion peut rugir et seul l'oiseau peut voler.
On peut ajouter des champs spécifiques à la classe fille.

1.2 Exemple (2)
● La classe Animal :
import java.awt.Color;
class Animal{
private Color couleur;
private int taille;
public Animal(){...}
public Animal(Color c, int t){...}
}
public void Manger(){...}
public void Dormir(){...}
public Color getCouleur(){...}
public int getTaille(){...}

2.1 Le mot clé extends
● On utilise le mot clé extends pour marquer l'héritage :
class Lion extends Animal{
private Color couleurCriniere;
}
public void Rugir(){...}
public void setCouleurCriniere(Color c){...}
public Color getCouleurCriniere(){...}
● Utilisation :
Lion leo = new Lion();
leo.Rugir();
leo.Dormir();
On ne peut hériter que d'une seule classe!

2.2 Les constructeurs
● Constructeur par défaut :
public Lion(){
}
super();
couleurCriniere = new Color(125, 125, 125);
Le mot clé super permet d'appeler un constructeur de la classe mère.
● Autre constructeur :
public Lion(Color c, int t, Color criniere){
}
super(c, t);
couleurCriniere = new Color(criniere.getRed(), criniere.getGreen(),
criniere.getBlue());
L'appel au constructeur de la classe mère est toujours la première instruction du
constructeur de la classe fille.

2.3 Les méthodes
●
La classe fille hérite de toutes les méthodes de la classe mère. Par
exemple si la classe Animal contient la méthode :
public String toString(){
}
return "Je mesure "+taille+" cm et je suis de couleur "+couleur;
On peut alors automatiquement écrire :
String description = leo.toString(); // leo est une instance de Lion
Je mesure X cm et je suis de couleur [color]"
Ceci permet de réduire la taille du code à écrire... ou à corriger!
Cependant on peut souhaiter spécialiser la méthode.

2.3 Les méthodes (2) :
Spécialisation
●
On peut redéfinir une méthode existante de la classe mère pour mieux
l'adapter à la classe fille :
public String toString(){
}
String description = "Je suis un lion avec une criniere
"+CouleurCriniere+"\n";
return description+super.toString();
Le résultat de la méthode toString() de la classe Lion est alors différent de
celui de la classe Animal :
String description = leo.toString(); // leo est une instance de Lion
"Je suis un lion avec une criniere [color]
Je mesure X cm et je suis de couleur [color]"

2.4 Interdire l'heritage
●
Il est possible d'interdire à tout autre programmeur d'hériter de votre
classe : on utilise alors le mot clé final.
final class Lion extends Animal{...}
... Il est maintenant impossible de créer une classe héritant de Lion.
●
De la même façon, on peut empêcher la redéfinition d'une méthode par
les classe filles :
public final String toString(){...} // Dans la classe mère
Il est maintenant impossible aux classes filles de redéfinir la méthode
toString().

3 Le polymorphisme
L'héritage exprime la relation "est un". Dans notre exemple, un lion est
un animal tout comme un oiseau l'est également. Il est donc logique de
pouvoir écrire :
Animal albert = new Lion();
Animal gustave = new Oiseau();
On peut ensuite appeler n'importe quelle méthode définie dans la classe
Animal :
System.out.println(albert.toString());
System.out.println(gustave.toString());
Dans ce cas, le compilateur va créer une liaison dynamique permettant
de choisir la méthode au moment de l'execution :
System.out.println(albert.toString()); // méthode Lion.toString()
System.out.println(gustave.toString()); // méthode Oiseau.toString()

3 Le polymorphisme (2)
On peut naturellement définir un tableau :
Animal[] animaux = new Animal[2];
animaux[0] = new Lion();
animaux[1] = new Oiseau();
et afficher le contenu de ce tableau :
for(Animal a : animaux){
System.out.println(a); // méthode toString()
}
"Je suis un lion avec une criniere [color]
Je mesure X cm et je suis de couleur [color]
Je suis un oiseau
Je mesure X cm et je suis de couleur [color]"

3 Le polymorphisme (3)
Ayant un tableau d'objets 'Animal', on ne peut appeler que les méthodes
de la classe Animal :
animaux[0].Dormir(); // OK
animaux[0].Rugir(); // NON!! N'existe pas dans la classe Animal!
Si on veux pouvoir utiliser toutes les fonctionalités de la classe, on doit
effectuer un transtypage :
((Lion)animaux[0]).Rugir(); // Compilation OK
Par contre rien ne prouve que animaux[0] soit une instance de Lion. On
peut donc avoir une erreur à l'execution! Pour l'éviter :
if(animaux[O] instanceof Lion)
((Lion)animaux[0]).Rugir(); // Uniquement si on a un Lion !

Classes abstraites
4 Classes et méthodes
abstraites
A mesure que l'on élabore la hiérarchie des classes, certaines peuvent
ne plus décrire des objets réels. Pour notre exemple, la classe 'Animal'
correspond elle à un objet utile, ou simplement à un concept abstrait?
Il est possible de déclarer une classe comme "abstraite", ceci aura 2
conséquences :
● Il n'est plus possible de créer une instance de la classe.
● La classe peut comporter des méthodes abstraites.
Méthodes abstraites
Une méthode abstraite est déclarée dans la classe mère mais n'est
implémentée que dans les classes filles.

4 Classes et méthodes
Déclaration d'une classe abstraite :
abstract class Animal{...}
abstraites (2)
Déclaration d'une méthode abstraite :
public abstract String toString(); // pas d'implémentation
Conséquence : toutes les classes héritant de Animal, si elles ne sont pas
abstraites elles­même, doivent implémenter la méthode toString().

5 La classe Object
Si une classe n'hérite pas explicitement d'une autre, alors elle
hérite de la classe Object.
Par conséquent, toutes les classes java héritent directement
ou indirectement de la classe Object.
Il est donc toujours possible d'écrire :
Object o = new NomDeLaClasse(...);

5 La classe Object (2)
La classe Object propose différentes méthodes dont vont
hériter toutes les classes java:
– String toString() : retourne une description de la
classe.
– boolean equals() : comparaison de deux objets
– Object clone() : retourne une copie de l'objet
Ces méthodes doivent souvent être redéfinies au niveau de la
classe pour être pertinentes.
Voire la documentation de la classe Object pour la liste complète des méthodes...

6.1 Les interfaces ­ Utilisation
Une interface est un ensemble de règles auxquelles doit se
conformer une classe. C'est une sorte de cahier des charges.
Exemple : La méthode sort() de la classe Arrays permet de
trier un tableau d'objets.
Condition : les objets doivent provenir d'une classe qui
implémente l'interface Comparable :
public interface Comparable
{
}
int compareTo(T other);

6.1 Les interfaces – Utilisation
(2)
Modifons la classe Animal pour implementer l'interface Comparable :
class Animal implements Comparable{// on peut implémenter plusieurs interfaces
[...]
public int compareTo(Animal other){
}
}
if (taille>other.taille) return 1;
if (taille

6.1 Les interfaces – Utilisation
(3)
Quelques propriétés des interfaces :
– Elles ne peuvent pas contenir de champs, mais elles peuvent
contenir des constantes
– Elles ne peuvent pas être instanciées
– On peut cependant déclarer des variables interfaces (ces variables
références des objets de classes implémentant l'interface)
– Une interface peut hériter d'une autre interface
– Une classe peut implémenter plusieurs interfaces

6.2 Les interfaces – Création
Ecrire une interface est très simple, il suffit de lui donner un nom et
d'énumérer les méthodes.
Par exemple, nous pouvons créer une interface Dessinable qui garantit
que les classes l'implémentant auront une méthode public void
Dessine(Graphics g) :
public interface Dessinable {
}
public void Dessine(Graphics g);
Comme pour une classe, ce code devra être placé dans un fichier nommé
Dessinable.java.

7 Le clonage
Le clonage permet d'obtenir une copie en profondeur d'un objet par
un appel à la méthode clone().
Cependant cette méthode est protected dans la classe Object!
Il faut donc la redéfinir dans la classe fille :
public Object clone() throws CloneNotSupportedException{
Personne p = (Personne)super.clone();
p.birthday = (Date)this.birthday.clone();
return p;
}

7 Le clonage (2)
Afin d'éviter une erreur lors du clonage (une classe fille qui ne
redéfinit pas correctement la méthode clone()), il est impératif
d'implémenter l'interface Cloneable pour indiquer que notre classe
gère le clonage. C'est une interface de balisage (elle ne contient
aucune méthode).
class Personne implements Cloneable{
...
}
Tout appel à la méthode clone() à partir d'une classe
n'implémentant pas Cloneable générera une exception
CloneNotSupportedException.

Gestion des exceptions
1.Envoi d'une exception
2.Réception d'une exception
3.Le mot clé finally
4.Créer ses propres exceptions

1. Envoi d'une exception
Si une méthode rencontre une situation qu'elle ne sait pas gérer,
elle peut envoyer une exception.
public void openFile(String name) throws
FileNotFoundException{
}
[...le fichier n'existe pas]
throw new FileNotFoundException();
[...]
Lors de l'envoi d'une exception, on sort de la méthode
immédiatement. Celle­ci ne retourne pas de valeur.

2. Réception d'une exception
La méthode pouvant envoyer une exception doit être appelée à
l'interieur d'un bloc try...catch:
try{
}
...
openFile(fileName);
...
catch(FileNotFoundException e){
}
System.out.println(“Aucun fichier trouvé!”);
Si exception
On peut enchaîner plusieurs blocs catch pour gérer plusieurs types
d'exception.

3. Le mot clé finally
On peut également utiliser un block finally qui sera executé qu'une
exception soit levée ou non :
try{
}
openFile(fileName);
catch(FileNotFoundException e){...}
catch(...){...}
finally{...}
Le bloc finally est exécuté :
– soit après le bloc try si aucune exception n'est envoyée
– soit après l'un des blocs catch si une exception a été envoyée.
– même si une instruction return a été rencontrée.

4. Créer ses propres exceptions
Pour créer une nouvelle classe pouvant être utilisée comme
exception, il suffit d'hériter de la classe Exception ou d'une de ses
classes filles:
public class MyException extends Exception {
}
public MyException(){}
public MyException(String message) {
}
super(message);
On pourra maintenant utiliser la classe MyException de la même facon
que la classe FileNotFoundException.
Le compilateur force le traitement des exceptions sauf pour les
RuntimeException.

Introduction aux interfaces
graphiques
1. AWT et Swing
2. Les classes de base
1. Créer une fenêre : JFrame
2. Ajouter un contenu : JPanel
3. JLabel
4. JTextField
5. JButton
6. Autres composants
3. Gestion des événements
1. Créer un écouteur
2. Classes internes
3. Lier un composant à un écouteur
4. Interfaces listener utiles

1. AWT et Swing
●
Abstract Window Toolkit (AWT) : première bibliothèque graphique
de Java
Appel des fonctions natives du système d'exploitation
La bibliothèque AWT est contenue dans la package java.awt.*
●
Swing : Standard depuis Java 2
Dessine tous les composants dans une fenêtre
La bibliothèque Swing est contenue dans la package javax.Swing.*

2.1 Créer une fenêtre : JFrame
La classe JFrame permet de créer une fenêtre graphique :
import javax.swing.*;
public class MyFrame extends JFrame {
public static final int HEIGHT = 250;
public static final int WIDTH = 300;
public MyFrame(String title){
super(title);//constructeur de JFrame
setSize(WIDTH, HEIGHT);
}}
public class Launcher{
public static void main(String args[]){
}}
MyFrame mf = new MyFrame("Nom de la fenetre");
mf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mf.setVisible(true);

2.1 Créer une fenêtre : JFrame
(2)
JFrame : fonctions utiles
– setTitle(String t) : donne un titre à la fenêtre.
– setSize(int w, int h) : stipule la taille de la fenêtre en pixels.
– setLocation(int x, int y) : stipule l'emplacement de la fenêtre.
– setDefaultCloseOperation(constante) : comportement du
programme lors de la fermeture de la fenêtre.
– setVisible(boolean b) : affiche ou cache la fenêtre.
– getContentPane() : retourne la couche "contenu" de la
fenêtre.

2.2 Ajouter un contenu : JPanel
Un JPanel est un composant sur lequel on peut dessiner et qui peut egalement
contenir d'autres composants. Pour déssiner sur un JPanel, il faut surcharger la
méthode void paintComponent(Graphics g).
import javax.swing.*;import java.awt.*;
public class MyPanel extends JPanel {
public void paintComponent(Graphics g){
}}
super.paintComponent(g);
g.fillRect(20,20,25,50);
public class Launcher{
public static void main(String args[]){
}}
MyFrame mf = new MyFrame("Nom de la fenetre");
mf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mf.getContentPane().add(new MyPanel());
mf.setVisible(true);

2.2 Ajouter un contenu : JPanel
(2)
Pour ajouter d'autres composants dans un JPanel, on lui affecte un
gestionnaire de mise en forme. On dispose de plusieurs
gestionnaires possibles :
– FlowLayout (défaut de JPanel) : Tous les composants sont ajoutés
horizontalement jusqu'à ce qu'il n'y ait plus de place sur la ligne, on
commence alors une nouvelle ligne.
– BorderLayout (défaut de JFrame) : L'espace est divisé en 5 zones
(Nord, Sud, Est, Ouest, Centre) et on doit affecter les composants à
l'une de ces zones.
– GridLayout : On divise l'espace en lignes et colonnes, un composant
est affecté à la case (x,y).
– GridBagLayout : Similaire à GridLayout, mais les cases peuvent
avoir des tailles différentes.
http://java.sun.com/docs/books/tutorial/uiswing/layout/using.html

2.3 JLabel
Un JLabel est un composant permettant d'afficher du texte qui ne pourra pas
être modifié par l'utilisateur.
import javax.swing.*;
import java.awt.*:
public class MyInterface{
private JLabel titre;
public MyInterface(){
}}
MyFrame mf = new MyFrame("Nom de la fenetre");
mf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JPanel j = new JPanel();
j.setLayout(new BorderLayout());//definition du gestionnaire
titre = new JLabel("Un titre pour la fenetre", JLabel.CENTER);
j.add(titre, BorderLayout.NORTH);
mf.getContentPane().add(j);
mf.setVisible(true);

2.4 JTextField
Un JTextField est un composant permettant à l'utilisateur de saisir du texte.
public class MyInterface{
private JLabel titre;
private JTextField text;
public MyInterface{
MyFrame mf = new MyFrame("Nom de la fenetre");
JPanel mainPanel = new JPanel();
mainPanel.setLayout(new BorderLayout());//definition du gestionnaire
titre = new JLabel("Saisir puis valider : ", JLabel.CENTER);
text = new JTextField(10);
JPanel saisiePanel = new JPanel();
saisiePanel.add(titre);
saisiePanel.add(text);
mainPanel.add(saisiePanel, BorderLayout.NORTH);
mf.getContentPane().add(mainPanel);
mf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mf.setVisible(true);
}}

2.5 JButton
Un JButton permet d'afficher un bouton sur lequel l'utilisateur pourra cliquer.
private JLabel titre;
private JTextField text;
private JButton bouton;
public MyInterface{
}
MyFrame mf = new MyFrame("Nom de la fenetre");
JPanel mainPanel = new JPanel();
mainPanel.setLayout(new BorderLayout());//definition du gestionnaire
titre = new JLabel("Saisir puis valider : ", JLabel.CENTER);
text = new JTextField(10);
bouton = new JButton("Quitter");
JPanel saisiePanel = new JPanel();
saisiePanel.add(titre);
saisiePanel.add(text);
mainPanel.add(saisiePanel, BorderLayout.NORTH);
mainPanel.add(bouton, BorderLayout.SOUTH);
mf.getContentPane().add(mainPanel);
mf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
mf.setVisible(true);

2.6 Autres composants
Il existe beaucoup d'autres composants graphiques. Entre autres :
– JComboBox : Composant affichant une liste.
– JRadioButton : Sélection d'une seule valeur parmi plusieurs boutons.
– JCheckBox : Composant pouvant prendre les valeurs vrai/faux.
– JTree : Permet d'afficher une arborescence.
– JProgressBar : Affiche la progression d'une action.
– JTabbedPane : Permet de passer d'un panneau à un autre en
utilisant des onglets.
Tous les composants graphiques héritent de javax.swing.JComponent.
http://java.sun.com/j2se/1.5.0/docs/api/javax/swing/JComponent.html

3. Gestion des événements
Une fois les composants graphiques mis en place, il faut pouvoir
récupérer les actions de l'utilisateur.
Composant
graphique
objet événement
objet
événement
objet
événement
Ecouteur 1 Ecouteur 2 Ecouteur N
...
Il faut donc :
– Créer un/des écouteur(s)
– Référencer les écouteurs au niveau des composants

3.1 Créer un écouteur
Le rôle de l'écouteur est d'attendre qu'un événement lui soit envoyé.
Il analyse cet événement et execute le code adéquate.
Pour créer un écouteur, il suffit d'implémenter une interface, par
exemple ActionListener :
class MyListener implements ActionListener{
public void actionPerformed(ActionEvent e){
}
}
Lorsqu'un événement est reçu, la méthode actionPerformed est
executée.

3.2 Classes internes
Les classes écouteurs sont spécifiques à l'interface développée.
Elles sont souvent placées à l'intérieur de la classe décrivant
l'interface graphique. Ce sont alors des classes internes.
Les classe internes :
– ont accès aux champs de la classe conteneur
– sont invisibles à l'extérieur de la classe conteneur

3.2 Classes internes (2)
public class MyInterface{
private JTextField text;
private JLabel titre;
private JButton bouton;
public MyInterface(){ ... }
class MyListener implements ActionListener{
public void actionPerformed(ActionEvent e){
if(e.getSource()==text){
System.out.println(text.getText());
}
if(e.getSource()==bouton){
System.out.println("Je quitte!!");
System.exit(0);
}
}
}}

3.3 Lier un composant à un
écouteur
Il nous faut maintenant créer une instance de notre classe écouteur:
public MyInterface{ ...
...}
MyListener listener = new MyListener();
Et indiquer à nos composants qu'ils doivent envoyer les
événements à ce listener :
public MyInterface{ ...
...}
MyListener listener = new MyListener();
bouton.addActionListener(listener);
text.addActionListener(listener);

3.4 Interfaces listener utiles
●
ActionListener : Touche entrée et boutons
● public void actionPerformed(ActionEvent e)
●
KeyListener : Evénements clavier
● public void keyPressed(KeyEvent e)
● public void keyReleased(KeyEvent e)
● public void keyTyped(KeyEvent e)
●
MouseListener : Clics et positionnement de la souris
● public void mouseClicked(MouseEvent e)
● public void mouseEntered(MouseEvent e)
● public void mouseExited(MouseEvent e)
● public void mousePressed(MouseEvent e)
● public void mouseReleased(MouseEvent e)

3.4 Interfaces listener utiles (2)
●
MouseMotionListener : Mouvements de la souris
● public void mouseDragged(MouseEvent e)
● public void mouseMoved(MouseEvent e)
Il existe bien d'autres interfaces écouteur. Toutes héritent de l'interface
EventListener
(http://java.sun.com/j2se/1.5.0/docs/api/java/util/EventListener.html).

Pour aller plus loin...
●
Le site officiel de Sun contient énormément d'informations :
documentation de l'API, exemples, tutoriaux...
– http://java.sun.com/j2se/1.5.0/docs/
●
De nombreux sites Internet proposent des exemples de code en
Java, un simple moteur de recherche permet souvent de trouver
des informations pertinentes.
●
Au coeur de Java 2 (Hortsmann & Cornell), CampusPress
●
Java Cookbook (Darwin), O'Reilly