CH 2 Classe

Langage Java SE
Chapitre 2 : Classe
Dr Konan Marcellin BROU
marcellin.brou@inphb.ci
2O19-2020
Sommaire
 Qu’est ce que la POO
 Création de classes et d’objets
 Les méthodes
 Les modificateurs
 Les packages
 La généricité
 Héritage
 Classes abstraites et
interfaces
 Les exceptions
 Bibliographie
K. M. BROU Langage Java : Classe 2
Sommaire
 Objectifs
 Savoir créer une classe et
l’utiliser.
 Comprendre les mécanisme de
réutilisation d’une classe.
 Savoir écrire un programme
utilisant des classes.

I. Qu’est-ce que la POO ?
 1.1. Présentation Approche classique Approche orientée objet
 Programmation Orientée Objet
 Objet ?
 Extension de la notion
d’enregistrement (struct).
Hiérarchie des
 Regroupe en une seule entité structures de données
données et fonctions de
traitement de ces données.
 Données et traitement séparé en Hiérarchie des
Hiérarchie unifiée
programmation classique de classes
procédures
K. M. BROU Langage Java : Généralités 4

 Objets du monde réel  Objet informatique
 Composé d'objets ayant deux  Maintient son état dans des
caractéristiques : variables appelées attributs.
 Un état ;  Implémente son comportement à
 Un comportement. l'aide de méthodes.
 Exemples 1 : Homme  Un objet informatique est le
regroupement logiciel d’attributs
 état = nom, couleur, race,
et des méthodes associées.
poids....
 Exemple : Un rectangle
 comportement = manger, crier,
marcher...  Attributs : longueur, largeur
 Exemples 2 : Voiture  Méthodes: calcul de son
périmètre, calcul de sa surface
 état = nombre de vitesses,
modèle, couleur
 comportement = rouler, tourner,
accélérer, changer de vitesse

 Cycle de vie des objets :  Classe ?
 Construction (en mémoire)  Modèle de définition pour des
 Utilisation objets partageant des
caractéristiques communes, mais
 changements d’état par
l'état de chaque objet est
affectation
indépendant des autres.
 comportements par exécution de
 Un objet (ou instance) est une
méthode
représentation dynamique du
 Destruction modèle défini au travers de la
classe.
 Une classe permet d’instancier
plusieurs objets.
 Chaque objet est instance d’une
seule classe.
 Exemple : classe Rectangle
 Classe de tous les rectangles
 1.2. Objectifs de la POO  Décentralisation :
 Plus les module sont autonomes,
 Conception de
plus la modification d’un module
logiciels extensibles et n’affectera que très peu de
réutilisables. modules.
 Améliorer la qualité d’un logiciel  Exemple :
en programmant moins et mieux.  Passer d’un programme en 2D à
 Extensibilité ? un programme en 3D.
 Facilité de modification d’un y y
logiciel lors d’un changement de
spécification. x
x z
 Simplicité de la conception :
 une architecture logicielle simple  2 solutions :
est plus facile à modifier.

 Solution 1 : Écrire carrément un  Exemple :
nouveau programme.
 Solution 2 : Ajouter une 3ième
cordonnée au programme en 2D.
 Modification du fichier source et
recompilation.
 Edition de liens.
 Test de tous les autres modules
du programme (test
d’intégration).
 L’extensibilité consiste à utiliser le
programme en 2D sans
modification et de créer une
3ième coordonnée ainsi que des
fonctions supplémentaires.

 Exemple : Point2D.java void lire() {
System.out.println("entrer les coordonnees du point : ");
import java.util.Scanner; Scanner lectureClavier = new Scanner(System.in);
System.out.println("Abscisse : ");
public class Point2D { x = lectureClavier.nextInt();
public double x, y; System.out.println("Ordonnee : ");
y = lectureClavier.nextInt();
public Point2D () { }
x = 0.0; double distance(Point2D p2){
y = 0.0; double d = Math.sqrt(Math.pow(p2.x-x,2) +
} Math.pow(p2.y-y, 2));
public Point2D (double abs, double ord) { return d;
x = abs; }
y = ord; static public void main(String argv[]) {
} Point2D p1 = new Point2D(1, 2) ;
public void affiche() { Point2D p2 = new Point2D(3, 4) ;
System.out.println("Abscisse = " + x); p1.affiche();
System.out.println("Ordonnee = " + y); p2.affiche();
} double d = p1.distance(p2);
System.out.printf("distance = %5.2f", d);
}
}

 Exemple : Point3D.java void lire() {
super.lire();
import java.util.Scanner; System.out.println("entrer la cote : ");
Scanner lectureClavier = new Scanner(System.in);
z = lectureClavier.nextInt();
public class Point3D extends Point2D { }
public double z; double distance(Point3D p2){
double d = Math.sqrt(Math.pow(p2.x-super.x,2) +
public Point3D() { Math.pow(p2.y-super.y, 2) + Math.pow(p2.z-z, 2) );
super(); return d;
z = 0.0; }
} static public void main(String argv[]) {
public Point3D(double abs, double ord, double cote) { Point3D p1 = new Point3D(1, 2, 3) ;
super(abs, ord); Point3D p2 = new Point3D(4, 5, 6) ;
z = cote; p1.affiche();
} p2.affiche();
public void affiche() { double d = p1.distance(p2);
super.affiche(); System.out.printf("distance = %5.2f", d);
System.out.println("Cote = " + z); }
} }

 Réutilisabilité ?
 Aptitude d’un logiciel à être
réutiliser en totalité ou en partie
dans de nouvelles applications.
 Exemple : programme de
recherche d’une donnée
 pouvoir utiliser le même
programme quelque soit le type
de donnée : entier, réel,
caractères, structure complexe…
 int rechercher(T t[], T x);

 1.3. Apports de la POO  Améliorer la productivité de
création d’un logiciel.
 Améliorer les facteurs de qualité
d’un logiciel. Qualité, Explication
Structuration Aptitude décomposer les traitements
Qualité Explication et les données en structures
Validité Aptitude à réaliser exactement les tâches définies clairement identifiées.
par sa spécification. Modularité Aptitude construire une application
Robustesse Aptitude à fonctionner même dans des conditions selon une combinaison de plusieurs
anormales. modules indépendants et
Extensibilité Facilité d’adaptation aux changements de réutilisables.
spécification. Lisibilité Facilité de compréhension du code.
Réutilisabilité Aptitude à être repris pour de nouvelles Vérifiabilité Facilité pour effectuer des procédure
applications de certification.
Compatibilité Aptitude à être combiné avec d’autre logiciels
Efficacité utilisation optimale des ressources du matériel et  Améliorer la maintenance d’un
vitesse d’exécution. logiciel.
Portabilité Aptitude à fonctionner dans des environnement
différents.  Lisibilité + Modularité +
Intégrité Aptitude à protéger ses composantes contre des Réutilisabilité permettent une
modifications non autorisées.
Ergonomie Facilité d’utilisation.
maintenance aisée d’un logiciel.
 1.4. Concepts de base
 Type Abstrait
 Généralisation/Spécialisation
 Classe/Objet
 Encapsulation
 Héritage
 Agrégation
 généricité
 Polymorphisme

 Type Abstrait (TA)  Différents types d’abstraction :
 L’abstraction consiste à penser à  Abstraction d’entités : capteur,
un objet en termes d’actions que personne, écran, avion, satellite…
l’on peut effectuer sur lui, et non  Abstraction de type structure de
pas en termes de représentation données : tableau, ensemble, pile,
file, liste…
et d’implantation de cet objet.
 Abstraction de type processeur :
 Définition : contrôleur, commande,
 L’abstraction est un processus qui compilateur, linker…
consiste à identifier les
caractéristiques intéressantes
d'une entité en vue d'une
utilisation précise. Elle désigne
aussi le résultat de ce processus,
c'est-à-dire l'ensemble des
caractéristiques essentielles d'une
entité, retenues par un
observateur.
 L’entité et ses propriétés
sont appelées Type Abstrait
 Généralisation/Spécialisation :  Agrégation ou composition :
 Permettent de construire une  Consiste à assembler plusieurs TA
hiérarchie de TA. simples afin de construire un TA
 Lien de généralisation, et lien de plus complexe.
spécialisation.  Lien d’agrégation ou de
composition, des TA simple au TA
Type complexe.
Généralisation
Simple Structuré Voiture
Standard manufacturé Carrosserie Moteur

Roue
Spécialisation
Entier Réel Caractère Lien d’agrégation
Lien de généralisation/spécialisation

 Le Type Abstrait Algébrique  Fonctions (ou opérateurs)
(TAA)  nouvelle :  PILET (création d’une
nouvelle pile).
 Un TAA est TA associé à des  vide : PILET  BOOLEEN (teste si
opérateurs algébriques. une pile est vide)
 Comporte 3 parties :  empiler : T x PILET  PileT (ajout
 Partie syntaxique : les opérateurs d’un élément de type T au sommet
 Partie sémantiques : les axiomes de la pile)
 Partie condition  dépiler : PILET  PILET (retrait de
l’élément se trouvant au sommet
 Exemple : de la pile)
 TAA Pile d’éléments de type T :  sommet : PILET  T (retourne de
PILET l’élément se trouvant au sommet
de la pile)

 3 types de fonctions :  Axiomes
 Fonction de création d’un TAA :  Pour tout t : T et p : PILET, On a les
 TAA (ex. nouvelle) axiomes suivants :
 Fonctions de transformation du  vide(nouvelle()) = VRAI
TAA : TAA  TAA (ex. empiler et  NON vide(empiler(t, p)) =
dépiler) VRAI
 Fonctions d’accès : TAA  T (ex.  sommet(empiler(t, p))= t
sommet et vide)  dépiler(empiler(t, p)) = p
 Préconditions
 depiler(p : PILET) = (NON vide(p))
 sommet(p : PILET) = (NON
vide(p))

 L’encapsulation  Permet de :
 Ou masquage de l’information  Protéger les données d’un objet
contre une manipulation
 Consiste à combiner données et dangereuse par un autre objet ;
opérations nécessaires pour  Rendre plus aisé la manipulation
traiter les données sous un même des données via une interface
toit. bien définie (partie publique) ;
 Elle combine une structure de  Dissimuler les détails de son
donnée (enregistrement) et un implémentation (partie privée) :
ensemble de sous programme Analogie avec un circuit intégré.
habilites à la manipuler.  Exemple :
 Ce nouveau type est appelé Rectangle
classe. -longueur
unRect : Rectangle
Partie -largeur
Privée longueur = 7.5
+int()
largeur = 5.23
+affiche()
Partie +perimetre() Objet : instance d’une classe
Publique
Classe
 L’instanciation  Communication par envoi de
 Opération de création dynamique messages
d’un exemplaire d’une classe  Envoyer un message à un objet,
(objet). c’est lui dire ce qu’il doit faire. La
 Exemple : création d’un objets réponse d’un objet à la réception
 Rectangle r1, r2; d’un message est une activation
 r1.init(12., 3.50) ; de méthode.
 r2.init(9.50, 13.50) ;  Exemple :
r1  envoi du message affiche() à
12. l’objet r1
Rectangle 3.50  r1.affiche() ;
longueur  Appelle de la méthode init().
largeur r2
9.50
13.50
Classe
Instances ou objets
 L’héritage  Exemple :
 Une procédure permettant de
 Permet de décrire une nouvelle permuter deux éléments de type T
classe (par extension, (int, float, Point…).
spécialisation) à partir d’une ou
PROCEDURE swap(DR T x, T y)
plusieurs autres classes. VAR T z ;
 Son intérêt est la réutilisation de DEBUT
classes existantes. z=x
x=y
 La généricité y=z;
FIN
 Paramétrisation de la définition
d’une fonction ou d’une classe.
 Intérêt : permettre l’écriture de
fonctions ou de classes flexibles
et réutilisables.

 Le polymorphisme  La méthode périmètre() de la
classe Figure est héritée par ses
 Mot grec signifiant "qui se
sous-classes (Rectangle,
présente sous différentes
Losange, Carré…).
formes".
 Capacité donnée à une même  Ces sous-classes peuvent
méthode de s’exécuter redéfinir cette méthode pour
l’adapter à leur réalité.
différemment suivant le contexte
de sa classe.  Si une de leur instance appelle la
méthode perimetre(), le système,
 Permet la définition d’entités
flexibles pouvant référencer des exécute la méthode périmètre()
qui a été redéfinie.
objets de formes variables à
l’exécution.
Classe
Figure Méthode périmètre()

II. Création de classe et d’objet
 2.1. Création d’une classes  Exemple : Point en 2 dimensions
public class Point2D {
 Java est "purement" orienté private double x, y;
objet public Point2D (double abs, double ord) {
 Pas de fonctions indépendantes x = abs;
comme en C++. y = ord;
}
 Toutes les classes héritent d’une
public void afficher() {
classe de base unique :
System.out.println("Abscisse = " + x);
 Classe Object du package System.out.println("Ordonnée = " + y
java.lang. }
 Déclaration d’une classe static public void main(String argv[]) {
Point2D p = new Point2D(3.45, 5.56) ;
 Syntaxe p.afficher();
[<modificateur>] class nomClasse [extends }
<nomSuperClasse>] [implements <interface1>, }
<interface2>,…] {
<attribut et méthodes>
}
 2.2. Création d’un objet  L’appel à l’opérateur new
déclenche une série d’actions :
 L’opérateur new détermine la
place mémoire nécessaire à la  Création de l’objet d’une classe ;
définition d’un objet.  allocation de la mémoire
nécessaire à cet objet ;
 Syntaxe
 Appel d’un constructeur (par
nomObjet = new nomClasse(parametres) ; défaut ou explicite).
 Exemple : MC
p
x 3.45
private double x, y; y 5.56
…
static public void main(String argv[]) {
Point2D p = new Point2D(3.45, 5.56) ;
p.afficher();  Deux sortes d’objet :
}
 Variable d’objet
}
 Variable de classe
 2.3. Les classes intérieures class CPrincipale {
 Depuis la version 1.1, Java a class CInterne {
int attribut = 10;
introduit la notion de classes }
intérieures (inner classes). static public void main(String args[]) {
 On ne peut créer un objet CPrincipale cp = new CPrincipale();
CInterne ci = cp.new CInterne();
instancié sur une classe
System.out.println("Attribut = " + ci.attribut) ;
intérieure qu'à partir d'un objet }
instancié sur la classe }
englobante.
 Exemple :

 2.4. Variable d’objet  Classe Cercle
class Cercle{
 Déclarées dans une classe , en Point2D centre = new Point2D(0, 0);
dehors d’une méthode. double rayon;
 Globales pour tous les objets de Color couleur;
la classe. import java.awt.Color;
void afficher() {
 Exemple : class Point2D { System.out.println("Rayon=" + rayon) ;
double x, y;
System.out.println("centre : x=" + centre.x + "
Point2D (double abs, double ord) { y="+ centre.y);
x = abs; System.out.println("Couleur=" + couleur);
y = ord; System.out.println();
} }
public void afficher() { }
System.out.println("Ordonnée = " + y  Variable classique : rayon
}
 variables objets : centre.
}
 Chaque objet a une valeur pour
ces variables.
 Classe principale
class MainVObjet{
static public void main (String args[]){
Cercle c1 = new Cercle();
//chaque instance a une valeur de centre et sa couleur
c1.centre.x = 3.45;
c1.centre.y = 2.20;
c2.centre.x = 4.50;
c2.centre.y = 3.56;
c1.couleur = Color.red; MC MC
c1 c2
c2.couleur = Color.green; centre.x 3.45 centre.x 4.50
System.out.println("Variable d'objet");
centre.y 2.20 centre.y 3.56
c1.afficher();
c2.afficher(); couleur red couleur green
}
}

 2.5. Variable de classe  Exemple :
 Globales pour une classe et pour import java.awt.Color;

class Point2D {
toutes ses instances.
…
 Utilisée pour faire communiquer }
entre eux les objets d’une même
classe. class Cercle {
 Utilisée pour définir des Point2D centre = new Point2D(); //v. d'objet
propriétés communes à un groupe double rayon;
static Color couleur; //v. de classe
d’objets de la même classe.
 Pour différencier les variables void affiche() {
d’objet des variables de classe on System.out.println("Abs du centre=" + centre.x) ;
utilise le mot-clé static. System.out.println("Ord du centre=" + centre.y) ;
System.out.println("Coul du cercle=" + couleur) ;
 Deux possibilités pour manipuler }
une variable de classe : }
 préfixée par le nom de la classe
 Ou K.
par le nom d’une instanceLangage Java : Classe  couleur : variable de classe
M. BROU 27
 Classe principale  Cercle.couleur = Color.red ; ou
class MainVClasse {  Cercle.couleur=new
static public void main(String argv[]) { color(0,255,0)
Cercle c1 = new Cercle(4.0, Color.red);  C1.couleur = Color.red ;
Cercle c2 = new Cercle(3.0, Color.red);
 Tous les objets ont la même
c1.centre.x = 3.45;
c1.centre.y = 2.20;
couleur
c2.centre.x = 4.50;
c2.centre.y = 3.56;
Cercle.couleur = Color.green;
System.out.println("Appel de la variable de classe");
c1.afficher();
System.out.println();
c2.afficher();
}
}

MC MC
c1 c2
centre.x 3.45 centre.x 4.50
Valeurs
centre.y 2.20 centre.y 3.56 initiales
couleur red couleur red
MC MC
c1 c2
centre.x 3.45 centre.x 4.50 Variables
2.20 3.56 de classe
centre.y centre.y
couleur green couleur green

III. Les méthodes
 3.1. Présentation  Appelée en donnant le nom de sa
classe ou le nom d’une instance
 Permettent la définition du de sa classe.
comportement d’un objet.  Exemple 1 : méthode main().
 Pas de fonctions indépendantes  static public void main(String
comme en C++. args[])
 Deux sortes de méthodes :  Exemple 2 : méthodes de la classe
 Méthode objet Math.
 Méthode de classe  Définie dans java.lang contient de
nombreuses méthodes de classe.
 Méthode de classe : à déclarer
 int a = Math.max (x, y) ;
static.
 Pas de création d’une instance de
 S’applique à la toute classe et non
la classe Math avant d’utiliser ses
à ses instances.
méthodes.
 Pas de création d’une d’une
instance avant de l’utiliser.

III. Les méthodes
class MainVClasse {
 Exemple :
import java.awt.Color;
class Point2D {
c1.centre.x = 3.45;
double x,y;
c1.centre.y = 2.20;
} c2.centre.x = 4.50;
class Cercle { c2.centre.y = 3.56;
Point2D centre = new Point2D(); //v. d'objet
Cercle.couleur = Color.green;
double rayon;
System.out.println("c1 appel de la variable de classe");
static Color couleur; //v. de classe c1.afficher();
System.out.println("c2 appel de la variable de classe");
void affiche() {
c2.afficher();
… Cercle.modifColor(Color.yellow);
}
System.out.println("Appel méthode de classe");
static void modifColor(Color c) {
c1.afficher();
couleur = c;
c2.afficher();
}
} 
}
}

III. Les méthodes
 Cercle.modifColor(Color.yellow);
ou MC MC
c1 c2
 ou C1.modifColor(Color.red ); centre.x 3.45 centre.x 4.50
Valeurs
Tous les objets ont la même centre.y 2.20 centre.y 3.56
 initiales
couleur couleur red couleur red
MC MC
c1 c2
Variables
centre.y 2.20 centre.y 3.56 de classe
couleur green couleur green
MC MC
c1 c2
Méthode
centre.y 2.20 centre.y 3.56
de classe
couleur yellow couleur yellow


III. Les méthodes
 3.2. Surcharge des méthodes  Classe Point2D
 Le polymorphisme autorise la import java.awt.Color;

définition de méthodes ayant le class Point2D {
même nom. double x, y;
 Mais avec des signatures

Point2D (double abs, double ord) {
différentes. x = abs; y = ord;
 Exemple : }
System.out.println("Ordonnée = " + y);
}
}

III. Les méthodes
 Classe Cercle  Classe principale
class Cercle { class MainSurcharge {
Point2D centre = new Point2D(0.0, 0.0); static public void main(String args[]) {
double rayon; Cercle c1 = new Cercle(4.0, Color.red);
static Color couleur; Cercle c2 = new Cercle(3.0, Color.green);
c1.centre.x = 3.45;
Cercle (double r, Color c) { c1.centre.y = 2.20;
centre = new Point2D(0, 0); c2.centre.x = 4.50;
rayon = r; couleur = c; c2.centre.y = 3.56;
} System.out.println("Avant appel de move()");
void afficher() {… c1.afficher();
} c2.afficher();
void move(double x) { c1.move(10.0);
centre.x = centre.x + x ; c2.move(20.0, 30.0);
} System.out.println("Après appel de move()");
void move(double x ,double y) { c1.afficher();
centre.x = centre.x + x ; centre.y = centre.y + y ; c2.afficher();
} }
} }

III. Les méthodes
 Exécution
MC MC
c1 c2
Valeurs
centre.y 2.20 centre.y 3.56 initiales
couleur red couleur green
MC MC
c1 c2
centre.x 13.45 centre.x 24.50 Après appel
2.20 33.56 de move()
centre.y centre.y
couleur red couleur green

III. Les méthodes
 3.3. Passage des paramètres
 Les arguments de type objets
sont passées par référence.
 Toute manipulation de l’objet à
l’intérieur de la méthode affecte
l’objet original.
 Cette règle de passage des
paramètres s’applique à tous les
objets ainsi qu’aux tableaux.
 Seul les variables de type simple
(int, Integer, float, String, …)
sont passées par valeur.

III. Les méthodes
 Mode de passage par valeur  Paramètre formel i : passé par
 La méthode ne manipule qu’une valeur
copie des paramètres effectifs.  Paramètre effectif z :
 Exemple 1 : type int  La modification de i n’affecte
pas z
public class ParValInt {
static public int inc(int i) {
i++;
return i;
}
public static void main(String[] args) {

MC MC
int z = 0; ;
int j = inc(z); z 0 z 0
System.out.println("z = " + z); j j 1
System.out.println("j = " + j);
i i 1
}
} Avant Après
 Z n’a pas élé modifier
III. Les méthodes
 Exemple 2 : type Integer  Paramètre formel i : passé par
valeur
 Paramètre effectif z :
public class ParValInteger {
static public int inc(Integer i) {  La modification de i n’affecte
i++; pas z
return i;
}

Integer z = 0;
Integer j = inc(z);
System.out.println("z = " + z); MC MC
System.out.println("j = " + j);
z 0 z 0
}
} j j 1
i i 1
Avant Après
 Z n’a pas élé modifier
III. Les méthodes
 Exemple 3 : type String  Paramètre formel s : passé par
valeur
 Paramètre effectif st :
public class ParValChaine {
public static void modif(String s) {  La modification de s n’affecte
s.concat(" Fatou"); pas st
}

String st = new String("Bonjour");
modif(st);
System.out.println(st);
MC MC
}
} st Bonjour st Fatou
s s Bonjour Fatou
Avant Après
 st n’a pas élé modifier

III. Les méthodes
 Mode de passage par référence public class ParRefInt {
static public Entier inc(Entier i) {
 Toute modification du paramètre
i.setValue(i.getValue()+1);
formel se répercute sur le
return i;
paramètre effectif.
}
 Exemple 1 : On crée une classe public static void main(String[] args) {
Entier class Entier { Entier z = new Entier(0);
private int value; Entier j = inc(z);
public Entier(int v) { System.out.println("z = " + z.getValue());
this.value = v; System.out.println("j = " + j.getValue());
} }
public void setValue(int v) { }
this.value = v; MC MC
} z 0 z 1
public int getValue() {
return this.value; j j 1
} i i 1
} Avant
 Z a été modifié Après
 Contient
K. M. BROU
un geter et un seter.Langage Java : Classe 40
III. Les méthodes
 Exemple 2 : chaine de caractères
public class ParRefChaine {
public static void modif(StringBuffer s) {
s.append(" Fatou");
}
StringBuffer st = new StringBuffer("Bonjour");
modif(st);
System.out.println(st);
MC MC
}
} st Bonjour st Bonjour Fatou
s s Bonjour Fatou
 Classe StringBuffer pour

Avant Après
manipuler une chaîne.
 st a été modifié

III. Les méthodes
 Exemple 3 : tableau
public class ParRefTableau{
static void modifier(int[] t) {
for (int i = 0 ; i < t.length ; i++)
t[i] += 10;
}
static void afficher(int[] t) {
for (int i = 0 ; i < t.length ; i++)
System.out.println("t[" + i + "] = " + t[i]);
}
public static void main(String[] args){ MC MC
int[] v = {1,2,3};
t[0] 1 t[0] 10
System.out.println("Avant");
afficher(v); t[1] 2 t[1] 20
modifier(v); t[2] 3 t[2] 30
System.out.println("Après"); Avant Après
afficher(v);
}
}  t a été modifié
III. Les méthodes
 3.4. La méthode main()  La tâche principale de cette
méthode est d'instancier des
 L'exécution d'un programme Java
objets sur différentes classes afin
démarre une JVM
que le programme puisse
 Son paramètre est le nom de la
s’exécuter.
classe de démarrage.
 Cette classe doit contenir une  La méthode main existe
méthode main(). indépendamment de toute
 JVM démarrée : instance de classe :
 Si elle doit utiliser des attributs ou
 Elle lance le programme
des méthodes de la classe, il faut
proprement dit par la première
que ces champs soient eux aussi
instruction de la méthode main().
déclarés static.
 Sans instancier d'objet à partir de
 Les méthodes déclarées static, sur
la classe de démarrage.
une classe, ne peuvent manipuler
 Ceci est possible car la méthode que des champs statiques.
main est une méthode de classe.
III. Les méthodes
 La méthode main admet en  Exemple : maximum de 2 entiers
paramètre un tableau de chaînes  2 arguments
de caractères ("String args[]"). class MaximumM {
 args[] : contient les options de la static int max(int x, int y) {
ligne de commande. return(x > y ? x : y);
}
 args.length : donne la taille du
static public void main(String args[]) {
tableau. int a,b, c, m ;
 Remarque : if(args.length == 2) {
 Le nom du paramètre peut être a = (Integer.valueOf(args[0])).intValue();
n'importe quel nom, mais on b = (Integer.valueOf(args[1])).intValue();
utilise souvent args, repris de la m = max(a, b) ;
System.out.println("Maximun = " + m);
terminologie du langage C/C++.
}
else
System.out.println("Nombre d'argument
insuffisant " + args.length);
}
}
III. Les méthodes
 3.5. Les constructeurs  Syntaxe
 Méthode spéciale utilisée pour <modificateur> nomClasse([<parametres>]){
initialiser les objets lors de leur …
création. }
 Automatiquement appelé lors de

l’exécution de l’opérateur new.  Le modificateur peut être public,
private ou protected.
 Il n'a pas de type de retour et a le
même nom que sa classe.
 Il acceptent la surcharge.
 Deux sortes de constructeurs :
 Constructeur par défaut (ne
possède pas d’arguments)
 Constructeur explicite (possède
des arguments).

III. Les méthodes
 Exemple :
void afficher() {
System.out.println("Rayon=" + rayon) ;
class Point2D {
System.out.println("centre : x=" + centre.x + " y="+ centre.y);
double x,y;
System.out.println("Couleur=" + couleur);
Point2D () {//CPD
x=0.0; y=0.0 ;
}
}
}
}
class Constructeur {
class Cercle {
Point2D centre ; double rayon;
Cercle c1 = new Cercle() ; // CPD
Color couleur;
Cercle c2 = new Cercle(3.0, Color.blue) ; // CE
Cercle () { //CPD
c1.afficher();
centre = new Point2D();
c2.afficher();
rayon = 2.0 ; couleur = Color.red ;
c1.centre.x = 3.45;
}
c1.centre.y = 3.56;
Cercle (double r, Color c) { //CE
c1.afficher();
}
rayon = r ; couleur = c ;
}
}
III. Les méthodes
 Exécution
MC MC
c1 c2
centre.x 0 centre.x 0
centre.y 0 centre.y 0
couleur red couleur bleue
MC MC
c1 c2
centre.x 3.45 centre.x 0
centre.y 3.56 centre.y 0
couleur red couleur bleue

III. Les méthodes
 Remarques  Règle 2
 Les constructeurs servent  Si vous en définissez au moins un,
principalement à définir l'état le constructeur par défaut n'est
initial des objets instanciés. plus fourni.
 Il est bien sûr possible d’initialiser  Si vous en avez besoin, il vous
les variables lors de leur faudra alors le définir
déclaration, mais le constructeur explicitement.
permet de créer des objets "sur
mesure".
 Règle 1 :
 Si aucun constructeur n'est défini,
dans la définition de la classe, un
constructeur par défaut est
obligatoirement fourni, celui-ci
n'admettant aucun paramètre.

III. Les méthodes
 3.6. Le gabage colllector  Remarques :
 L’opérateur new se charge  L’utilisation d’un destructeur est
optionnelle et assez rare.
d'allouer de la mémoire à la
demande.  Le rôle accompli par le Garbage
Collector est assez suffisant.
 si l'on ne libère pas la mémoire
des objets devenus inutiles, on MC
p
peut rapidement manquer de x 0
mémoire. 0
y
 Le Garbage Collector ou ramasse-
Point2D p = new Point2D();
miettes
 Chargé de repérer les objets
inutiles, et de libérer la mémoire MC
qu'ils occupent inutilement.
 Il opère de façon totalement
automatique.
Libération de la mémoire

III. Les méthodes
 3.7. Le destructeur  Syntaxe
 Pas de surchage ;
 Permet d'exécuter du code lors
de la libération, par le garbage  Il a forcément le nom finalize
collector, de l'espace mémoire  il n’a pas de paramètre ;
occupé par l'objet.  Il a le type void et public.
 Il appelés automatiquement par public void finalize() {
le garbage collector. …
 Pour créer un finaliseur, il faut }
redéfinir la méthode finalize()
héritée de la classe Object.

III. Les méthodes
 Exemple :
class Point2D{
double x,y;
Point2D (){
x=0.0;
y=0.0 ;
}
public void finalize(){
System.out.println("Objet point (2D) dtruit");
}
}
class Destructeur {
static public void main(String argv[]){
Point2D p = new Point2D();
p.finalize();
}
}

Exercice
 Exercice 1 :  Déclarer une matrice :
 TPEleveNote.java : Ecrire un  float note[][] = new float[N][2];
programme permettant  Matrice N lignes, 2 colonnes
manipuler une classe Eleve.
 Les attributs sont :
 matricule, nom, age
 et une matrice de notes
 la 1ère colonne contient les notes
 la 2e les coefficients respectifs.
 On doit avoir les méthodes
suivantes :
 un constructeur par défaut ;
 un constructeur explicite ;
 une méthode calcul moyenne ;
 une méthode affiche.
 On fera des saisies au clavier.

IV. Les modificateurs
 4.1. Définition  Quatre grandes catégories :
 Mots-clés modifiant la définition  Modificateurs de contrôler d’accès
et le comportement d’une classe, : public, private, protected
d’une méthode ou d’une variable.  Modificateur pour les variables et
méthodes de classe : static
 Modificateur pour "figer"
l’implémentation d’une classe,
d’une méthode ou d’une variable :
final
 Modificateur pour la création de
classes ou de méthodes abstraites
: abstract.

 Il existe d’autres modificateurs :  volatile
 synchronized  Il précise que la variable peut être
 Utilisés pour les threads changée par un périphérique ou
de manière asynchrone. Cela
 Il permet de gérer l'accès
indique au compilateur de ne pas
concurrent aux variables et
stocker cette variable dans des
méthodes lors de traitements de
registres. A chaque utilisation, sa
threads (exécution simultanée de
valeur est lue et réécrite
plusieurs petites parties de code
immédiatement si elle a changé.
du programme),
 native
 Utilisé pour la création de
méthodes natives (écrites dans
d’autres langages comme C++).

 4.2. Le contrôle d’accès  Lorsqu’une classe est publique,
elle doit être dans un fichier qui a
 Le modificateur public le même nom.
 public pour signifier qu’une
classe, une méthode ou une
double x,y;
variable est accessible n’importe
}
où dans "l’univers des classes
Java" (même dans d’autres
packages).  Ce code doit être dans le
 Le mot-clé public est le mode par fichier Point2D.java
défaut.
class Point2D {
double x,y;
}
 idem
class Point2D {
public double x,y;
}
 Exemple : class Cercle{
Point2D centre = new Point2D(0, 0);
import java.awt.Color; double rayon;
Color couleur;
class Point2D { void afficher() {
public double x, y; System.out.println("Rayon=" + rayon) ;
Point2D (double abs, double ord) { System.out.println("centre : x=" +centre.x + " y="+centre.y);
x = abs; System.out.println("Couleur=" + couleur);
y = ord; System.out.println();
} }
public void afficher() { }
System.out.println("Abscisse = " + x); class Modificateur{
System.out.println("Ordonnée = " + y); static public void main (String args[]){
}
c1.centre.x = 3.45;
}
c1.centre.y = 2.20;
 classes Cercle et Modificateur c1.couleur = Color.red;
c1.afficher();
peuvent accéder à x et à y car
}
déclarés public. }
 Le modificateur private  Exemple :
 Diamétralement opposé au  Dans Modificateur.java,
modificateur public. remplacer public par private.
 Forme de protection la plus import java.awt.Color;
restrictive
 Limite la visibilité des méthodes et class Point2D {
des variables d’instance à la private double x, y;
classe dans laquelle elles sont
x = abs;
définies.
y = ord;
 Les sous-classes ne peuvent }
hériter ni de variables privées, ni public void afficher() {
de méthodes privées. System.out.println("Abscisse = " + x);
System.out.println("Ordonnée = " + y);
}
}

class Cercle{  classes Cercle et Modificateur ne
Point2D centre = new Point2D(0, 0);
peuvent accéder à x et à y car
double rayon;
déclarés private.
Color couleur;
void afficher() {
System.out.println("Rayon=" + rayon) ;
System.out.println("centre : x=" +centre.x + " y="+centre.y);
System.out.println("Couleur=" + couleur);
}
}
class Modificateur{
c1.centre.x = 3.45;
c1.centre.y = 2.20;
c1.couleur = Color.red;
c1.afficher();
}
}
 Le modificateur protected  Exemple 2 : remplacer dans
 Il s’agit d’une forme de protection Modificateur.java, le mot clé
entre classe et sous-classes. private par protected.
 Le mot-clé protected signifie :  On constate qu’il n’y a plus
d’erreur.
 que les méthodes et les variables
d’une classe donnée demeurent
accessibles à toute classe du
même package (différence avec
C++) ;
 Mais ne sont accessibles, en
dehors du package, qu’aux sous-
classes de la classe à laquelle elles  Exemple 2 : sur les sous-classes
appartiennent.  C.f. Chapitre 3 : Héritage

 Les accesseurs :  Exemple :
 Les données déclarées private à public class Point2D {
l'intérieur d'une classe ne peuvent private double x, y;
être accédées et modifiées que …
par des méthodes définies dans la public void setX(double abs) {
x = abs;
même classe.
}
 Si une autre classe veut accéder public double getX() {
aux données de la classe, return x;
l'opération n'est possible que par }
l'intermédiaire d'une méthode de public void setY(double ord) {
la classe prévue à cet effet. y = ord;
 C’est une méthode publique qui }
donne l'accès à une donnée public double getY() {
return y;
privée.
}
 Accesseurs en lecture : get …
 Accesseurs en écriture : set. }

 Classe principale  Exécution
class Accesseur{
Point2D p = new Point2D(3.45, 2.20);
System.out.println("Appel du constructeur");
p.afficher();
p.setX(5.25);
p.setY(2.31);
System.out.println("Appel du setter");
p.afficher();
System.out.println("Appel du getteur");
System.out.println("p.x = " + p.getX());
System.out.println("p.y = " + p.getX());
}
}

 La notion de package  Au lieu de la protection au niveau
 Aux trois modificateurs de des fichiers (comme en C/C++),
contrôle d’accès (public, private et Java utilise le concept de package.
protected) :  Les méthodes et les variables d’un
 On peut ajouter le mot package. packages sont visibles par toutes
les autres classes du package ;
 Bien que package ne soit pas un
modificateur en soi, il comporte  Mais pas par les classes d’autres
un niveau implicite de protection packages.
d’accès.  Java comporte ses propres
 Il permet d’organiser des groupes packages qu’il est possible
de classes ayant un même objectif d’utiliser dans un programmes
et des fonctions similaires.  Exemple : import java.io.* ;

 Le modificateur "static"  Résumé
 Il est utilisé pour définir des Visibilité public protected private package
variables ou des méthodes de Depuis la même oui oui oui oui
classe. classe
 static indique que l’élément est Depuis toute autre oui oui non oui
stocké dans la classe. classe du même
package
 Il est possible de "mixer" des
Depuis toute autre oui non non non
modificateurs de contrôle d’accès classe extérieure au
avec static. package
 Exemple : Depuis une sous- oui oui non oui
classe du même
class Cercle { package
public static float pi = 3.14 ; Depuis une sous- oui oui non non
void Move { classe extérieure au
… package
}
…
}
 4.3. Figer une implémentation  Appliqué à une méthode
 Le modificateur final permet de  final signifie que la méthode ne
"figer" l’implémentation d’une peut pas être redéfinie par les
sous-classes.
classe, d’une méthode ou d’une
variable.  Ceci permet de verrouiller
certaines méthodes dites
 Appliqué à une variable sensibles.
 final indique que la "variable" est  C.f. Chapitre 3 : Héritage
constante.
 Appliqué à une classe
 Exemple :
 final empêche la classe d’avoir des
class Cercle { sous-classes.
public static final float pi = 3.14 ;  Ceci a pour avantage de donner
} moins de travail au
microprocesseur, donc d’accroître
les performances du programme.
 C.f. Chapitre 3 : Héritage
V. Les packages
 5.1. Définition  Raisons d’utiliser les packages :
 Package Ou paquetages  Organisation des classes en unité
(de la même façon qu’on a des
 Permet d’organiser des classes. dossiers ou des répertoires) ;
 Il contient un nombre quelconque  Réduction des conflits de noms ;
de classes reliées entre elles par  Protection des classes, des
leur objectif, leur portée ou leur méthodes ou des variables.
héritage.
 Il devient intéressants à utiliser
dès que l’application contient
beaucoup de classes.

V. Les packages
 5.2. La commande import  Remarque :
 Pour utiliser un package il faut  Le caractère "*" est différent de
faire appel à la commande celui utilisé à la suite d’un prompt
pour spécifier le contenu d’un
import.
répertoire.
 Importer une classe individuelle  Par exemple, si l’on demande
 Exemple : import java.util.Vector ; d’afficher le contenu du répertoire
 Importer tout un package de classes/java/awt/*, cette liste
classe inclut les fichiers .class et tous les
sous répertoires tels que peer et
 Exemple : import java.awt.* ;
image.
 La commande import java.awt.*
 importe toutes les classes
publiques de ce package mais pas
les sous packages peer et image.
 L’import ne marche que "sur un
niveau".
V. Les packages
 5.3. Créer ses propres  Exemple :
packages  Créer l’arborecence suivante
 Définir au début de chaque classe SourceJava
une ligne du type : MainPackage.java
 package monPackage ;
Figure
 Toutes les classes appartenant au
package monPackage se trouvent Pont2D.java
dans un répertoire monPackage. Cercle.java
 Remarques :
 Il faut préciser dans la variable
d’environnement CLASSPATH  MainPackage.java : classe de test
l’ensemble des chemins des  Figure : nom du package
racines des packages à importer.
 Point2D.java : classe Point2D
 Un package par répertoire.
 Cercle.java : classe Cercle.java

V. Les packages
 Fichier Point2D.java  Fichier Cercle.java
package Figure;
package Figure;
public double x, y; public class Cercle{
Point2D (double abs, double ord) { public Point2D centre = new Point2D(0, 0);
x = abs; public double rayon;
y = ord; public Color couleur;
}
public void afficher() { public void afficher() {
System.out.println("Abscisse = " + x); System.out.println("Rayon=" + rayon) ;
System.out.println("Ordonnée = " + y); System.out.println("centre : x=" + centre.x + "
y="+ centre.y);
} System.out.println("Couleur=" + couleur);
} System.out.println();
}
}

V. Les packages
 Fichier MainPackage.java  Compiler MainPackage.java et
l’exécuter.
import Figure.*;
class MainPackage{
c1.centre.x = 3.45;
c1.centre.y = 2.20;
 Si c’est nécessaire ajouter le
c1.rayon = 5.25;
dossier SourceJava dans le
c1.couleur = Color.red;
CLASSPATH.
c1.afficher();
} SET CLASSPATH=D:\SourceJava
}

V. Les packages
 5.4. Conflit de nom
 Entre deux classes de packages
différents.
 Pour lever l’ambiguïté, il suffit de
préfixer le nom de la classe par le
nom du package.
 Exemple :
 Deux packages ayant chacun une
classe "Cercle".
import MonPackage.* ;
import SonPackage.* ;
MonPackage.Cercle c1 = new Cercle () ;
SonPackage.Cercle c2 = new Cercle () ;

V. Les packages
 5.5. Visibilité des packages  Il faut donc déclarer public les
 Une classe ou une interface : classes utilisées par les clients
utilisant le package et cacher les
 déclarée public est accessible en
dehors du package. classes donnant les détails
 Si elle n’est pas déclarée public,
d’implémentation.
elle est accessible à l’intérieur du  Ainsi, quand on change
même package, mais cachée en l’implémentation, les clients ne
dehors. sont pas concernés par les
changements puisqu’ils n’y ont
pas accès.

V. Les packages
 Exemple :
 La classe Point2D n’est plus public
package Figure;
class Point2D {
public double x, y;
x = abs;
y = ord;
}
System.out.println("Ordonnée = " + y) ;
}
}

V. Les packages
 La compilation de  Exercice
MainPackage.java comporte des  On voudrait que les attributs des
erreurs du type : classes Point2D et Cercle soit de
 x in Point2D is defined in an type private.
inaccessible class or interface  Modifier ces classes en
 c1.centre.x = 3.45;. conséquence.
 Exécuter la classe de test
MainPackage.
 Que constatez-vous ?
 Donnez une explication.
 Proposer une solution pour que la
classe de test MainPackage puisse
fonctionner correctement sans
erreur.

VI. La généricité
 6.1. Définition
 La généricité permet de définir
des classes, ou des méthodes
paramétrées par une ou plusieurs
autres classes.
 Classe Object

 6.2. Problème avec la classe  Classe Paire
Object class Paire {
Object premier ;
 Classe Object est héritée par Object second;
toutes les classes. Paire (Object a, Object b) {
premier = a;
 Son utilisation pour paramétrer
second = b;
les types nécessite de faires un }
cast. Object getPremier() {
 Erreur générée : return premier;
}
Genericite.java:27: error: incompatible types: Object getSecond() {
Object cannot be converted to String return second;
String x = p.getPremier(); }
void affiche() {
 Exemple : System.out.println("Premier = " +
premier + " Second = "+second);
}
}
 Classe principale  Cast obligatoire
class Genericite1 {
static public void main(String args[]) { class Genericite1 {
Paire p = new Paire ("abc", "xyz"); static public void main(String args[]) {
Paire d = new Paire (19., 45.); Paire p = new Paire ("abc", "xyz");
p.affiche(); Paire d = new Paire (19., 45.);
d.affiche(); p.affiche();
String x = p.getPremier(); d.affiche();
System.out.println("Premier = " + x); String x = (String)p.getPremier();
} System.out.println("Premier = " + x);
} }
}
 Erreur à la compilation

 6.3. Classe générique  Utilisation
 Ou patron de classe
class nomClasse2 {
 Permet de définir une famille de T2 v1, v2, v3 ;
classes paramétrées par un ou nomClasse1<T2> v1 = new nomlasse1<T2>();
plusieurs types. …
v1 = methode(v2, v3);
 Syntaxe }
class nomClasse1<T> {
T attribut ;
 Remarque :
…
T methode (T a, T b) {  Pour les type simple, utiliser leur
… classe.
}  Integer pour int
}  Double pour double

 Exemple :  Classe principale
class Point2D<T>{ class TestPoint2D{
Tx; static public void main(String args[]){
T y; Point2D<Integer> p1 = new Point2D<Integer>(1, 2);
p1.affiche();
Point2D(T a, T b){ Point2D<Double> p2 = new Point2D<Double>(19., 45.);
x = a; p2.affiche();
y = b; }
} }
void affiche(){  Plus de cast à effectuer

System.out.println("x = " + x + " y = "+y);
}
}

 6.4. Méthode générique  Utilisation
 Ou patron de méthode ou modèle class nomClasse2 {
de méthode. T4, T5 v1, v2;
T5 v3 ;
 Syntaxe nomClasse1<T4, T5> v1 = new nomlasse1<T2>();
…
class nomClasse1<T1, T2> {
v1 = meyhode(v2, v3);
T1 attribut ;
}
T2 attribut ;
…
T1 methode (T1 a, T2 b) {
…
}
}

 6.5. Plusieurs paramètres  Utilisation
 Syntaxe class nomClasse2 {
T4 v1, v2;
class nomClasse1<T1, T2> { T5 v3 ;
T1 attribut1 ;
T2 attribut2 ; nomClasse1<T4,T5> v1 = new nomClasse1<T4,T5>();
… …
T1 methode (T1 a, T2 b) { v1 = methode(v2, v3);
… }
}
}

 Exemple :  Classe principale
class Point2D<T1, T2>{ class TestPoint2Db{
T1 x ; static public void main(String args[]){
T2 y; Point2D<Integer,Integer> p1 = new Point2D<Integer,Integer>(1,2);
Point2D<Double,Double> p2 = new Point2D<Double,Double>(19.,45.);
Point2D(T1 a, T2 b){ Point2D<Integer,Double> p3 = new Point2D<Integer,Double>(1,45.);
x = a; p1.affiche();
y = b; p2.affiche();
} p3.affiche();
}
}  Plus de cast à effectuer
void affiche(){
}
}

 6.6. Généricité et calcul  Utilisation
 Exemple class TestPoint {
class Point2D<T> { Point2D<Integer> p1 = new Point2D<Integer>(1, 2);
public T x,y; Point2D<Double> p2 = new Point2D<Double>(19., 45.);
Point2D(T abs, T ord) { p1.affiche();

x=abs; p2.affiche();
y=ord; System.out.printf("Distance p2 : %.2f\n", p2.distance());
} }
double distance() {
double x2 = (double)x*(double)x;
double y2 = (double)y*(double)y;
return Math.sqrt(x2+y2);
}
void affiche(){
}
}
VII. Héritage
 7.1. Présentation  Hériter d’une classe
 Consiste à recevoir toutes les
 Propriété de pouvoir copier propriétés de cette classe et à y
virtuellement les caractéristiques adjoindre éventuellement des
de classes déjà définies dans la éléments supplémentaire.
définition de nouvelles classes.  Spécialisation
 Soit par extension : ajout de  Les différents membres hérités
nouvelles propriétés; peuvent être redéfinis afin de
 Soit par une spécialisation : prendre en compte les spécificités
affinement de propriétés de la classe héritière.
 Mécanisme permettant de  Principe de substitution
factoriser les propriétés  Toute instance de la classe
communes à un ensemble de héritière peut être considérée
classes. comme une instance de la classe
 Permet de réduire le code source. mère.
Classe A Superclasse
Classe B Classe héritière

VII. Héritage
 Caractéristiques :
 Toutes les classes font partie Object
d’une hiérarchie stricte.
Classe A Classe B
 Chaque classe possède une super-
classes et un nombre quelconque
de sous-classes.
 Surcharge (overloading)
 Les sous-classes héritent des
attributs et des comportements de  Surcharge de fonction (ou de
leurs super-classes. méthodes)
 On peut attribuer le même nom à
 Ceci évite de réécrire le code
concerné. plusieurs fonctions.
 La classe Object  Redéfinition (overriding)

 C’est la possibilité de redéclarer
 Elle se trouve au sommet de la
les mêmes attributs et méthodes
hiérarchie des classes.
d’une super classe au sein d’une
 Toutes les classes en héritent. sous classe.

VII. Héritage
 Deux sortes d’héritage :  Remarque :
 Héritage simple : la classe fille n’a  Il n’y a pas d’héritage multiple en java
qu’une seule classe mère. comme en C++.
Véhicule Rectangle ObjetPostal
Voiture Camion Rectangle plan Lettre
courrierAdim
 Héritage multiple : la classe fille a

plusieurs classes mères.
Losange Rectangle
Carré
 Carré : angles droits et côté
égaux.
 Rectangle : angles droits et côté
différents.
 Losange : angles pas droits et
côté égaux.
VII. Héritage
 Exemple :
Point centre
Figure Figure
Color couleur
centre
couleur
Point centre
Color couleur
Cercle
rayon
Carre Cercle
côté rayon
 Les membres (méthodes et

données) hérités sont dupliqués
dans la clase dérivée comme le
montre la figure ci-dessus.
 En fait les méthodes ne sont pas
réellement dupliquées.

VII. Héritage
 7.2. Utilisation de l’héritage
 Mécanisme permettant de
factoriser les propriétés
communes à un ensemble de
classes.
 Syntaxe
class B extends A{
…
}

VII. Héritage
 Classe de base
public void Move(double x){
centre.x = centre.x + x;
}
public class Figure{
public void Move(){
public Point2D centre;
centre.x = centre.x + 1.0;
Color couleur;
centre.y = centre.y + 1.0;
public Figure(){
}
public void affiche(){
couleur = Color.red;
System.out.println("Centre("+centre.x+","+centre.y+")");
}
System.out.println("Couleur=" +couleur);
public Figure(Point2D p, Color c){
centre = new Point2D(p.x, p.y);
}
couleur = c;
}
}
public void Move(double x ,double y){
centre.y = centre.y + y;
}
VII. Héritage
 Classes héritières  Classe Cercle
 Classe Carré import java.awt.Color;
import java.awt.Color; public class Cercle extends Figure{
public class Carre extends Figure { public double rayon;
public static double cote; public Cercle(){
public Carre(){ super();
super(); rayon = 2.0;
cote = 2.0; }
super.couleur=Color.yellow;//couleur=Color.yellow; public Cercle (Point2D p, double r, Color c){
} super(p, c);
public Carre(Point2D p, double cote, Color c){ rayon = r;
super(p, c) ; }
this.cote = cote; public void affiche(){
} …
public void affiche(){ }
… }
}
}
VII. Héritage
 7.3. Les mots-clés this et
super
 this : sert à accéder aux membres
de la classe courante.
 super : sert à accéder aux
membres de la super classe :
 attributs, méthodes ou des
constructeurs.

VII. Héritage
 Référence à un attribut  Appel de constructeur
 Exemple : class Carre extends Figure {
double cote ;
class Carre extends Figure {
double cote ;
Carre() {
Carre() {
super() ;
this.cote = 2.0;
this.cote = 2.0;
super.couleur=Color.yellow;
super.couleur=Color.yellow;
}
}
…
}
Carre(double cote, Color c) {
super(c) ;
this.cote = cote ;
}
}
 super() : appel du CPD de Figure

 super(c) : appel du CE de Figure
VII. Héritage
 7.4 Règles pour l’appel des  Une conséquence évidente est
qu'on ne peut utiliser qu'un seul
constructeurs appel au constructeur de la classe
 Si la première instruction d'un mère.
constructeur ne commence pas  Exemple :
par le mot clé super :
 Le constructeur par défaut de la public Carre(){
classe mère est appelé. super();
 Ne pas oublier de le définir. cote = 2.0;
super.couleur=Color.yellow;//couleur=Color.yellow;
 Appel du constructeur de la
}
classe mère public Carre(Point2D p, double cote, Color c){
 Il ne peut se faire qu’à la super(p, c) ;
première instruction du this.cote = cote;
constructeur. }

VII. Héritage
 Classe principale  Exécution
public class MainCarre{

Carre c1 = new Carre();
Carre c2 = new Carre(p, 2.25, Color.magenta);
c1.affiche();
c2.affiche();
}
}

VII. Héritage
 Exercice :
 Compléter la classe Eleve de
l’exercice 1 en ajoutant une classe
Personne dont elle héritera.
 Une Personne sera caractérisée
par :
 Un nom, un âge,
 Un constructeur par défaut, un
constructeur explicite et une
méthode affiche.

VII. Héritage
 7.5. Le sous-typage  Règles de substitution
 Héritage  On distingue le "Upcasting" et le
"Downcasting".
 Permet de créer des sous-types
d’un type de base.  Supposons deux classes B et C
dérivées d’une classe A.
 Type de base
 Rassemble les éléments
communs. A
 Sous-type
B C
 Caractérisé par des attributs et
méthodes supplémentaires.
 Certaines méthodes peuvent être
redéfinies afin de tenir compte
des spécifiées d’une sous-classe
particulière.

VII. Héritage
 Upcasting  Une sous-classe peut être
 Une instance de B peut remplacer convertie dans le type de sa
une instances de A super-classe ;
 Une fois convertie dans ce sens,
A
on ne peut accéder qu’aux champs
définis dans la super-classe ;
B C  Les méthodes surchargées de la
sous-classe peuvent être
B b; appelées.
b = new B (…) ;
A a;
a =b;

VII. Héritage
 Exemple : classe swap de la classe  Exécution
Figure
public void swap(Figure f){
centre = f.centre;
couleur = f.couleur;
}
public class MainUpcasting{

Point2D p1 = new Point2D(3.45, 3.56);
Figure f1 = new Figure();
Figure f2 = new Figure(p2, Color.red);
Carre c1 = new Carre(p1, 2.25, Color.magenta);
f1.swap(f2); //appel normal
f1.affiche();
f1.swap(c1); //substitution
f1.affiche();
}
}
VII. Héritage
 Downcasting  Exemple :
 Une instance de A peut être import java.awt.Color;
converti en une instance B : public class MainDowncasting{
 on utilise le cast.
A Figure f1 = new Figure(p1, Color.red);
Carre c1 = new Carre();
B C c1 = (Carre)f1;
c1.affiche();
B b; }
b = new B (…) ; }
A a;  Compilation sans erreur
b = (B)a ;  Mais erreur à l’exécution

VII. Héritage
 Opérateur "instanceof"  Exemple 2 : c1 instance de la
 Permet de trouver la classe d’une classe Figure à cause de l’héritage
instance. if (c1 instanceof Figure)
System.out.println("f1 instance de Figure");
 renvoie true ou false.
else
 Exemple 1 : f1 instance de la System.out.println("f1 pas instance de Figure");
classe Figure
if (f1 instanceof Figure)
System.out.println("f1 instance de Figure");
else
System.out.println("f1 pas instance de Figure");

VII. Héritage
 7.6. Avantages de l’héritage
 Supprime les redondances dans
le code.
 Possible de rajouter facilement
une classe
 A moindre coût : l'on peut
réutiliser le code des super-
classes.
 Extension : ajout de nouvelles
propriétés
 Propriétés directement utilisables
dans l'ensemble des sous-classes.
 Spécialisation :
 Affinement des propriétés
existantes
VII. Héritage
 Exercice :
 Créer un tableau de personnes
 Lui affecter indifféremment des
instances de Personne et
d’Eleves.
 Personne p, tp[3];
 Eleve e;
 Tp[0] = p;
 Tp[1] = e;

VIII. Classes abstraites et interfaces
 8.1. Les classes abstraites  Elles sont définies par leur
signature.
 Classes dont le seul but est de
 Modificateur abstract : permet de
factoriser des informations
déclare les classes et les
communes aux sous-classes.
méthodes abstraites.
 Elles n’ont pas d’instance, mais
peuvent contenir tout ce qu’une  Exemple : classe Figure
classe peut contenir (variables  Méthode est abstraite
méthodes…).
Figure affiche()
 En plus elles peuvent contenir des
méthodes abstraites.
 Les méthodes abstraites
Carre Cercle
 Moyen de factoriser, dans des
super-classes, des méthodes  Les sous classes de Figure doivent
communes dont l’implémentation redéfinir la méthode affiche().
est définie dans les sous-classes.  Impossible de créer une instance
 Elles n’ont pas d’implémentation d’une classe abstraite.
 Super classe Figure2
public void Move(double x){
}
abstract public class Figure2{
public void Move(){
public Point2D centre;
centre.x = centre.x + 1.0;
Color couleur;
centre.y = centre.y + 1.0;
public Figure2(){
}
abstract public void affiche();
couleur = Color.red;
}
}
public Figure2(Point2D p, Color c){
centre = new Point2D(p.x, p.y);
couleur = c;
}
public void Move(double x ,double y){
centre.y = centre.y + y;
}
 Sous classe Carre  Sous classe Figure
import java.awt.Color; import java.awt.Color;
public class Carre2 extends Figure2 { public class Cercle2 extends Figure2{
public static double cote; …
… public void affiche(){
public void affiche(){ System.out.println("Rayon=" +rayon) ;
System.out.println("Cote=" +cote); System.out.println("Centre("+centre.x+","+centre.y+")");
System.out.println("Centre("+centre.x+","+centre.y+")"); System.out.println("Couleur=" +couleur);
System.out.println("Couleur=" +couleur); System.out.println();
System.out.println(); }
} }
}

 Classe de test
public class MainCarre2{

Carre2 c1 = new Carre2();
Carre2 c2 = new Carre2(p, 2.25, Color.magenta);
c1.affiche();
c2.affiche();
}
}

 Créer une instance d’une classe
abstraite
 Figure2 c1 = new Figure2();
 Génère une erreur

 8.2 Les interfaces  Exemple :
 Classe dont toutes les méthodes class Point2D {
sont abstraites. public double x,y;
 Généralisation du concept de }
interface Figure3 {
classe abstraite.
Point2D centre = new Point2D() ;
 Plus besoin de spécifier que les public void init(double c, double x ,double y) ;
méthodes sont abstraites car elles public double perimetre();
doivent forcément l'être. public void move(double x, double y);
 Syntaxe : public void affiche();
}
 on utilise le mot clé interface au
lieu class.
 on a uniquement la signature des
méthodes

 Implémenter une interface  On dit qu’un objet implémente
 Bien que les interfaces bénéficient une interface X :
du mécanisme de l’héritage, on  si, vu de l’extérieur, cet objet est
n'hérite pas d'une interface, mais capable de répondre à tous les
on l'implémente. messages présentés dans cette
 En d'autres termes, on doit interface.
forcément fournir le code de
toutes les méthodes de l'interface
utilisée.
 sauf dans le cas d'une classe
abstraite qui implémente une
interface, ou bien d'une interface
dérivée d'une autre.
 On utilise le mot-clé implements
(et non extends) pour signifier
que l’on implémente une
interface.
 Exemple : si Carre implémente
l’interface Figure, on pourra
écrire :
class Figure2 implements Figure {

}
Class TestFigure {
Figure2 f;
…
f.init() ;
f.perimetre();
f.move() ;
f.affiche();
}

IX. Exceptions
 9.1. Définition
 Une exception est une
interruption de l'exécution d'un
programme suite à une erreur.
 Par exemple, une division par zéro
provoque une exception de type
ArithmeticException.
 Java permet la gestion et la
création d'exceptions.

IX. Exceptions
 9.2. Fonctionnement
 Une méthode qui rencontre un
problème impossible à traiter
immédiatement :
 Lève une exception (instructions
throw)
 En espérant que le programme
appelant pourra la traiter
(instructions try, catch, finally).
 Une méthode qui gère ce genre de
problèmes doit intercepter
l’exception (instruction throws).

IX. Exceptions
 9.3. Les exceptions
prédéfinies
 Les exceptions sont de véritables
objets.
 Ce sont des instances de classes
qui héritent de la classe
Throwable.
 Lorsqu’une exception est levée,
une instance de la classe
Throwable est créée.

IX. Exceptions
 Les instances de la classe Error :  les autres exceptions
correspondent à des événements
 Ce sont des erreurs internes à la
anormaux échappant au contrôle
JVM.
du programme.
 Elles sont rares et fatales.
 Par exemple, l’exception
 Les sous-classes de la classe EOFException est levée si on
Exception sont réparties en deux essaie de lire au-delà d’un fichier.
catégories :
 les exceptions d’exécution
(runtime) sont souvent l’effet du
manque de robustesse du code.
 Par exemple l’exception
NullPointerException est levée
lorsque l’on manipule un objet non
instancié (pas d’instruction new) ;

IX. Exceptions
 9.4. Traiter les exceptions  Syntaxe générale
levées Try {
 les mots clés try, catch et finally instructions;
instructions;
Instruction Explication
instructions;
Try { Section de code où une
}
} exception peut être levée.
catch( ExceptionType1 e) {
catch (IOException e) { Section de code à exécuter traitement de ce cas anormal (de type ExceptionType1);
} pour une exception }
donnée. catch( ExceptionType2 e) {
catch ( capturer plusieurs traitement de ce cas anormal (de type ExceptionType2);
NullPointerException pe) exceptions en multipliant throw e; // l'exception est propagée vers le bloc
{ les clauses catch. try/catch) englobant
} }
finally { Ce bloc (facultatif) permet finally {
} d'introduire un code qui traitement de fin de bloc try ;
sera exécuté, qu’une
}
exception soit levée ou
non.
IX. Exceptions
 10.5. Intercepter une  Exemple : ensemble des
exceptions liées aux E/S.
exception public void maMethode (int x) throws IOEXception {
 Si une méthode est susceptible …
}
de lever une exception et si elle
ne peut pas la traiter, elle se doit  Intercepter plusieurs exceptions
de prévenir le système qu'elle public void maMethode (int x) throws IOException,
relaye cette tâche. EOFException {
…
 on utilise le mot clé throws dans }
la définition de la méthode.
 throws permet d'avertir le
système qu'une certaine catégorie
d'exception ne sera pas traitée en
local.

IX. Exceptions
 Exemple 1 : division par zéro  Exécution
 ExceptionStandard.java
 Pas d’exception
RUN 1
public class ExceptionStandard { Entrer le numerateur : 6
public static void main(String[] args) { Entrer le denominateur : 3
Saisie fenetre = new Saisie(); z=x/y=2
System.out.print("Entrer le numerateur : ");
int x = fenetre.readInt(); //saisie de x RUN 2
System.out.print("Entrer le denominateur : "); Entrer le numerateur : 6
int y = fenetre.readInt(); //saisie de y Entrer le denominateur : 0
int z = x / y; donne
System.out.println("z = x / y = " + z) ; Exception in thread "main"
java.lang.ArithmeticException at
}
ExceptionStandard.main(ExceptionStandard.java:8)
}

IX. Exceptions
 Exemple 1 : division par zéro  Exécution
 ExceptionStandard1.java
RUN
 Gestion d’exception Entrer le numerateur : 6
public class ExceptionStandard1 { Entrer le denominateur : 0
public static void main(String[] args) { donne
try { erreur division par zero
Saisie fenetre = new Saisie();
System.out.print("Entrer le numerateur : ");
int x = fenetre.readInt(); //saisie de x
System.out.print("Entrer le denominateur : ");
int y = fenetre.readInt(); //saisie de y
int z = x / y;
System.out.println("z = x / y = " + z) ;
}
catch(ArithmeticException ae) {
System.out.println("erreur division par zero") ;
}
}
}
IX. Exceptions
 Exemple 2 : débordement de tableau  ExceptionStandard2.java
 Exécution
public class ExceptionStandard2 {
public static void main(String[] args) { RUN
try { javac ExceptionStandard2.java
int x = Integer.parseInt(args[0]); java ExceptionStandard2 6
int y = Integer.parseInt(args[1]); erreur 2 arguments sont attendus
try {
int z = x / y;
System.out.println("z = x / y = " + z) ;
}
}
}
catch(ArrayIndexOutOfBoundsException e) {
System.out.println("erreur, 2 arguments sont attendus") ;
}
}
}
IX. Exceptions
 Exemple 3 : un mauvais format  ExceptionStandard3.java
de nombre  Exécution
public class ExceptionStandard3 { catch(NumberFormatException nfe) {
public static void main(String[] args) { System.out.println("erreur, mauvais format de nombre
try { " + nfe.getMessage());
int x = Integer.parseInt(args[0]); }
int y = Integer.parseInt(args[1]); }
try { }
int z = x / y;
System.out.println("z = x / y = " + z) ; RUN
} javac ExceptionStandard3.java
catch(ArithmeticException ae) { java ExceptionStandard3 a
System.out.println("erreur division par zero") ; erreur, mauvais format de nombre For Input String "a"
}
}
System.out.println("erreur, 2 args sont attendus") ;
}
IX. Exceptions
 Exemple 4 : finally{ }  ExceptionStandard4.java
 dès l’entrée dans le bloc try/catch  Exécution
public class ExceptionStandard4 {
finally {
System.out.println("exception finalement");
try {
}
int x=Integer.parseInt(args[0]), y=Integer.parseInt(args[1]);
}
try {
}
int z = x / y; System.out.println("z = x / y = " + z) ;
}
RUN
javac ExceptionStandard2.java
java ExceptionStandard a
}
erreur, mauvais format de nombre For Input String
}
"a"
exception finalement
}
catch(NumberFormatException nfe) {
System.out.println("erreur, mauvais format de nombre " +
nfe.getMessage()) ;
}
IX. Exceptions
 Exemple 5 : Propagation d’une  ExceptionStandard5.java
exception  Exécution
public class ExceptionStandard5 { catch(NumberFormatException nfe) {
public static void main(String[] args) { System.out.println("erreur, mauvais format de
try { nombre " + nfe.getMessage()) ;
int x = Integer.parseInt(args[0]); throw nfe;
int y = Integer.parseInt(args[1]); }
try { finally {
int z = x / y; System.out.println("exception finalement");
System.out.println("z = x / y = " + z) ; }
} }
catch(ArithmeticException ae) { }
}
}
}

IX. Exceptions
 ExceptionStandard5.java
 Exécution
RUN
javac ExceptionStandard2.java
java ExceptionStandard a
erreur, mauvais format de nombre For Input String "a"
exception finalement
Exception in thread "main" java.lang.NumberFormatException: a
at java.lang.Integer.parseInt(Integer.java:435)
at java.lang.Integer.parseInt(Integer.java:476)
at ExceptionStandard.main(ExceptionStandard.java:7)

IX. Exceptions
 9.6. Exceptions définies par le  Le programmeur doit lui-même
lever ses exceptions.
programmeur
 Une méthode qui est disposée à
 Java offre au programmeur la intercepter l’exception l’indique
possibilité de définir ses propres par instruction throws.
exceptions.  Le mot-clé throw permet de créer
 Ces exceptions doivent hériter une instance de l’exception.
d’une autre exception de la  Pour le reste (try, catch, finally) le
hiérarchie des classes Java. mécanisme est identique.

IX. Exceptions
 Exemple 1 :
public static void main (String args []) {
 AEgalBException.java try {
class AEgalBException extends Exception { maMethode(2,2);
public String message () { System.out.println ("Pas d'erreur");
return "A égal à B !"; }
} catch (AEgalBException e) {
} System.out.println ("Erreur " + e.message());
//Fichier EssaiException.java }
public class EssaiException { }
static void maMethode (int a, int b) throws AEgalBException { }
if (a == b)
throw new AEgalBException (); RUN
else Erreur A egal a B !
System.out.println (a +" et "+ b + " OK !"); Si dans le main() on a maMethode(2,3)
} On aura :
2 et 3 OK !

IX. Exceptions
 Exemple 2 :  TestDivZException.java
public class TestDivZException {
 DivZeroException.java
static void maMethode (int a, int b) throws DivZeroException {
class DivZeroException extends Exception { if (b==0)
public String message () { throw new DivZeroException();
return "Division par zero !"; else
} System.out.println (a/b);
} }
public static void main(String args []) {

try {
maMethode(6,3);
System.out.println ("Pas d'erreur");
}
catch (DivZeroException e) {
System.out.println("Erreur " + e.message());
}
}
}
Bibliographie
 Ouvrages  Webographie
 Exercices en Java, Claude Delannoy,  Support de cours java de l’École
Eyrolles Nationale des Sciences
 Programmer en Java, Claude Géographiques (java.pdf)
Delannoy, Eyrolles  Manuel java – HES/SO – Eric
Lefrancois, Ecole d’ingénieur de
Genève, Département de l’instruction
Publique (manueljava.pdf).
 Penserenjava.zip
 http://igm.univ-
mlv.fr/~chilowi/teaching/subjects/j
ava/intro/collections/index.std.html
 http://www-inf.it-
sudparis.eu/cours/CSC4002/EnLigne
/Cours/CoursJAVA/7.40.65.html

CH 2 Classe

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

CH 2 Classe

Transféré par

Droits d'auteur :

Formats disponibles

Langage Java SE

Dr Konan Marcellin BROU

K. M. BROU Langage Java : Classe 3

K. M. BROU Langage Java : Généralités 4

K. M. BROU Langage Java : Généralités 5

K. M. BROU Langage Java : Généralités 7

K. M. BROU Langage Java : Généralités 8

K. M. BROU Langage Java : Généralités 9

K. M. BROU Langage Java : Généralités 10

K. M. BROU Langage Java : Généralités 11

K. M. BROU Langage Java : Généralités 13

Standard manufacturé Carrosserie Moteur

K. M. BROU Langage Java : Classe 15

K. M. BROU Langage Java : Classe 16

K. M. BROU Langage Java : Classe 17

K. M. BROU Langage Java : Classe 20

K. M. BROU Langage Java : Classe 21

K. M. BROU Langage Java : Classe 24

K. M. BROU Langage Java : Classe 26

 Globales pour une classe et pour import java.awt.Color;

K. M. BROU Langage Java : Classe 28

couleur red couleur red

couleur green couleur green

K. M. BROU Langage Java : Classe 29

K. M. BROU Langage Java : Classe 30

K. M. BROU Langage Java : Classe 31

K. M. BROU Langage Java : Classe 32

 Le polymorphisme autorise la import java.awt.Color;

 Mais avec des signatures

K. M. BROU Langage Java : Classe 33

K. M. BROU Langage Java : Classe 34

couleur red couleur green

couleur red couleur green

K. M. BROU Langage Java : Classe 35

K. M. BROU Langage Java : Classe 36

public static void main(String[] args) {

public static void main(String[] args) {

public static void main(String[] args) {

 st n’a pas élé modifier

 Classe StringBuffer pour

K. M. BROU Langage Java : Classe 41

 Automatiquement appelé lors de

K. M. BROU Langage Java : Classe 45

couleur red couleur bleue

centre.y 3.56 centre.y 0

couleur red couleur bleue

K. M. BROU Langage Java : Classe 47

K. M. BROU Langage Java : Classe 48

K. M. BROU Langage Java : Classe 49

K. M. BROU Langage Java : Classe 50

K. M. BROU Langage Java : Classe 51

K. M. BROU Langage Java : Classe 52

K. M. BROU Langage Java : Classe 53

K. M. BROU Langage Java : Classe 54

K. M. BROU Langage Java : Classe 57

K. M. BROU Langage Java : Classe 59

K. M. BROU Langage Java : Classe 60

K. M. BROU Langage Java : Classe 61

K. M. BROU Langage Java : Classe 62

K. M. BROU Langage Java : Classe 65

K. M. BROU Langage Java : Classe 67

K. M. BROU Langage Java : Classe 68

K. M. BROU Langage Java : Classe 69