TOA Cours Version Finale

Techniques Objet Avancées
Exemple d’illustration : Les classes Point et TestPoint
Public classe Point {

Public void initialise (int abs , int ord) { x = abs ; y = ord }
Public void deplace (int dx , int dy) { x += dx ; y = += dy }
Public void affiche() {
System.out.println( "je suis un point : " , + x + " " + y }
Private int x ;
Private int y ;
}
Public classe TestPoint {
Public static void main (String args []) {
Point a;
a = new Point ();
a.initialization(3, 5);
a.deplace(2, 0) ;
a.affiche() ;
}
}
Techniques Objet Avancées Pr. Abdelkrim Amirat Page 1

Chapitre 1 : Les classes et les objets
1- Introduction
a
Point a;
@dr a = new Point() ;
X=? ---------------------
Y=? Point a = new Point();
2- Mise en ouvre d’un programme comportant plusieurs classes
a- Un fichier source par classe
Point.java  Point.class
TestPoint.java  TestPoint.class
La machine virtuelle cherche une méthode main, parcontre dans un environ-nement

intégré les choses se déroulement d’une manière plus au mois automatique avec la
notion de projet Java/Eclipse.
b- Plusieurs classes dans un même fichier source

Un fichier source peut contenir plusieurs classes mais une seule doit être publique. La
classe contenant la méthode main doit obligatoirement être public, afin que la machine
virtuelle y ait accès.
Si Point est dans TestPoint là il faut supprimer Public de Point,

Une classe n’ayant aucun attribut d’accès reste accessible à toutes classes du même
package (du même fichier).
Si la méthode main est dans la classe Point (définition de la classe et son utilisation
dans le même fichier. Dans ce cas la méthode main aurait accès aux champs privés de la
classe, ce qui ne correspond pas aux conditions usuelles d’utilisation.
Si nous avons plusieurs classes dans le même fichier alors une seule doit être public
parceque le fichier doit avoir le même nom que la classe public.
Généralement on doit dissocier les classes et les rendre publiques pour pouvoir les
réutiliser le plus largement possible.

3- Les constructeurs
Dans l’Exemple d’illustration nous avons utilisé la méthode ‘Initialiser()’ pour initialiser les
attributs d’un objet de type point.
 Un appel obligatoire de ‘Initialiser()’ au moment opportun.
La notion de constructeur permet d’automatiser le mécanisme d’initialisation d’un

objet (il pourra s’agir de n’importe quelles actions utiles au bon fonctionnement de
l’objet).
Un constructeur n’est rien d’autre qu’une méthode, sans valeur de retour, portant le
nom de la classe. Il peut disposer d’un nombre quelconque d’argument
(éventuellement 0).
Point a = new Point() : ne convient plus

Point a = new Point (1,3) : ok

Public Point (int abs , int ord) { x = abs ; y = ord } // à la place Initialiser
Public void deplace (int dx , int dy) { x += dx ; y = += dy }
System.out.println( "je suis un point : " , + x + " " + y }
Private int x ;
Private int y ;
}
- Par essence un constructeur ne fournit aucune valeur de retour,

- Une classe peut ne disposer d’aucun constructeur,
- Un constructeur ne peut pas être appelé directement depuis une autre méthode.
Résumé
La création d’un objet entraine toujours les opérations suivantes :
 Une initialisation par défaut de tous les champs de l’objet,

 Une initialisation explicite lors de la déclaration du champ,
 L’exécution des instructions du corps du constructeur.

4- Champs de classe "Static"
Considérant la définition suivante :
Classe A {
Int n ;
Float y ;
}
A a1 = new A () ;
A a2 = new A () ;
Java permet de définir ce qu’on nomme des champs de classe (ou statique) qui n’existent
qu’en un seul exemplaire.
Classe B {
Static Int n ;
Float y ;
}
B b1 = new B () ;
B b2 = new B () ;
Ecrire un programme Java utilisant une classe Obj destine à contenir, à tout moment, le
nombre d’objet de type Obj.
5- Méthodes de classes "Static"

 C’est une méthode qui ne peut agir que sur les champs de la classe.
 Java permet de définir ces méthodes en les déclarant static.
 Une méthode de classe ne pourra en aucun cas agir sur des champs usuels puisque
elle n’est liée à aucun Objet particulier.
6- Sur-définition de méthodes ‘surcharge/overload’

Plusieurs méthodes peuvent porter le même nom, pour peu le nombre et le type de leurs
arguments permettent au compilateur d’effectuer son choix.

Exemples :
Public void deplace (int dx, int dy)
Public void deplace (int dx)
Public void deplace (int dx, int dy, int dz)
Public void deplace (short dx) { x += dx} il faut faire un caste (short)
7- Sur-définition et droits d’accès
Exemple :
8- Transmission d’objets en argument

Introduire dans la classe ‘Point’ une méthode nommée coïncide chargé de détecter la
coïncidente éventuelle de deux points.
Public boolean coincide (Point pt) {

return ( ( pt.x ==x ) && ( pt.y == y ) ) ;
}
Pubic class TestCoincide {

public static void main (String args [] ) {
Point a = new Point (1,3);
Point b = new Point (2,5);
Point c = new Point (1,3);
System.out.println( a.coincide (b) + “----“ + b.coincide(a));
System.out.println( a.coincide (c) + “----“ + c.coincide(a));
}
}
Coïncide compare les coordonnées de l’objet fourni implicitement lors de l’appel (x,y) avec
celles de l’objet pt reçu en argument (pt.x, pt.y).
On voit que la méthode coïncide, appelée par un objet ‘a’, est autorisée à accéder aux
champs privés d’un autre objet ‘b’ de la même classe.

Conclusion :
 En Java, l’unité d’encapsulation est la classe et non l’objet.
 Seules les méthodes d’une classe peuvent accéder aux champs privés de cette classe
(cette autorisation concerne les objets de la classe, et non seulement l’objet courant).
 Il y a une symétrie qui provient du mécanisme d’appel de méthode.
Résolution du même problème avec une méthode static :

Public static boolean coincide (Point p1, Point p2) {
return ( ( p1.x ==p2x ) && ( p1.y == p2.y ) ) ;
}

Chapitre 2 : Les classes internes
1- Introduction
Soit la définition Java suivante :
Class E
{ …………….
Class I
{ ……………..
}
……………………..
}
La définition de la classe I n’introduit pas d’office de membre de type I dans E.
En fait, la définition de I est utilisable au sein de la définition de E, pour l’instancier quand

on le souhaite un ou plusieurs objets de ce type.
Premier schéma d’utilisation de la classe interne I

Class E
{ …………….
Public void fe()
{ I i = new I() }
Class I
{ ……………..
}
……………………..
}
Un objet de la classe E ne contient aucun membre de type I,
Simplement, une de ses méthodes fe() utilise le type I pour instancier un objet de ce type.

Deuxième schéma d’utilisation de la classe interne I
Class E
{ …………….
Class I
{ ……………..
}
……………………..
Private I i1, i2 ;
}
Ici un objet de la classe E contient 2 membres de type I, nous n’avons pas précisé comment
les objets correspondants seront instancier (Comment ?)
Ce sera par le constructeur de E ou par une méthode de E,…..
Remarques
1- Un objet d’une classe interne est tjrs associé, au moment de son instanciation, à un
objet d’une classe externe dont on dit qu’il lui a donnée naissance.
2- Un objet d’une classe interne à tjrs accès aux champs et méthodes (même privés) de
l’objet externe lui ayant donnée naissance (accès restreint à l’objet et non à tous les
objets de cette classe).
3- Un objet d’une classe interne à tjrs accès aux champs et méthodes (même privés) d’un
objet interne auquel il a donnée naissance.
4- Une méthode statique n’est associe à aucun objet, par conséquent, une méthode
statique d’un classe externe ne peut créer aucun objet d’une classe interne.
5- Une classe interne ne peut pas contenir des membres statiques.
Exemple
Ecrire une classe Cercle utilisant une classe nommée Centre (point), interne à Cercle.
La classe Centre possède un constructeur et une méthode affiche().
La classe Cercle possède un constructeur, une méthode affiche() et une méthode déplace().

Exercice
Construire l’objet cylindre qui est composé de deux objet cercle et une hauteur h.
package TP03_1_Cylindre;
public class Cylindre {

class Cercle {
class Point {
public Point(int a, int b) {
x = a;
y = b;
}
public void affiche() {
System.out.println(x + " , " + y);
}
private int x, y;
}
public Cercle(int x, int y, double r) {

p = new Point(x, y);
this.r = r;
}

System.out.print(" de centre :" + r + " et des coordonées: ");
p.affiche();
}
public void deplace(int dx, int dy) {

p.x += dx;
p.y += dy;
}
private Point p;
private double r;
}
// ****************** End Cercle ******************
public Cylindre(int x1, int y1, int x2, int y2, double r, int h) {
c1 = new Cercle(x1, y1, r);
c2 = new Cercle(x2, y2, r);
this.h = h;
}

System.out.print("Je suis un cylindre de hauteur :" + h + " et de cercle de haut");
c1.affiche();
System.out.print("et de cercle de bas");
c2.affiche();
System.out.println("*******************************************");
}
public void deplace(int dx, int dy) {

c1.deplace(dx, dy);
c2.deplace(dx, dy);
}
private Cercle c1, c2;

private int h;
}
package TP03_1_Cylindre;
import java.util.Scanner;
public class TestCylindre {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

System.out.print("X1=");
int x1 = sc.nextInt();
System.out.print("Y1=");
int y1 = sc.nextInt();
System.out.print("X2=");
int x2 = sc.nextInt();
System.out.print("Y2=");
int y2 = sc.nextInt();
System.out.print("Rayon=");
double r = sc.nextDouble();
System.out.print("Hauteur=");
int h = sc.nextInt();
Cylindre c = new Cylindre(x1,y1,x2,y2,r,h);

c.affiche();
c.deplace(3, 2);
c.affiche();
}
}

2- Déclaration et instanciation d’un objet d’une classe interne
Il faut tjrs rattacher un objet d’une classe interne à un objet de sa classe englobante,
moyennant l’utilisation d’une syntaxe particulière de new().
Class E
{ …………….
Class I
{ ……………..
}
……………………..
}
- En dehors de E, on peut tjrs déclarer une référence à un objet de type I :
E.I i ; // référence i interne à E

- Mais la création d’un objet de type I ne peut se faire qu’en le rattachant à un objet
de sa classe englobante.
Si on dispose d’un objet e crée ainsi :
E e = new E() ;
Alors on peut affecter à i la référence
i = new e.I() ;
3- Classes internes locales

Class E
{ …………….
Void f()
Final int 15; float x;
Class I
{ ……………..
}
I i = new I();
}
……………………..
}

 L’instanciation d’objet de type I ne peux se faire que dans f().
 Un objet de type I a lors accès aux variables locales finales de f().
4- Classe Interne Statique
Class E
{ …………….
Public static Class I
{ ……………..
}
……………………..
}
Depuis l’extérieur on peut instancier un objet de la classe I de cette façon :
E.I i = new E.I() ;
L’objet i n’est plus associé à aucun objet de type E,
La classe I n’a plus accès aux membres de E, sauf s’il s’agit de membres statiques.

Chapitre 3 : Clonage d’objet
1- Introduction (copie d’un objet)

L’affectation de variables de type objet se limite à la recopie de références. Elle ne provoque
pas la recopie de la valeur des objets.
- La démarche la plus réaliste consiste plutôt à prévoir dans la classe correspondante une
méthode destinée à fournir une copie de l’objet concerné, comme le montre l’exemple.
Class Point {
Public Point (int x, int y) { this.x = x ; this.y = y}
Public Point Copie () {
Point p = new Point (x,y);

p.x = x ; p.y = y ;
return p ;
Private int x , y;
}
…………………………………………………………….
Point a = new Point (1,2);

Point b = new a.copie(); // b est une copie conforme de a
Cette démarche est utilisable tantque la classe concernée ne comporte pas de champs
de type classe.
- La copie superficielle d’un objet (Shallow copy)
On se contente de recopier la valeur de tous les champs, y compris ceux de type

classe ;
- La copie profonde d’un objet (Deep copy)

On recopie les valeurs des champs d’un type primitif mais pour les champs de
type classe, on crée une nouvelle référence à un autre objet du même type de
même valeur.
2- L’interface Cloneable
Java dispose de quelques outils destinés à faciliter la gestion du clonage des objets (copie
profonde). La classe Object possède une méthode clone protégée qui se contente d’effectuer
une copie superficielle de l’objet. L’idée des concepteurs de Java est que cette méthode doit
être redéfinie dans toute classe clonable.
Par ailleurs, il existe une interface très particulière Cloneable. Ce nom s’emploie comme un
nom d’interface dans une clause implements. Mais n’impose pas la redéfinition de la
méthode clone.
En fait, la déclaration :
Class X implements Cloneable
Ceci signifie que la classe X peut subir une copie profonde par appel de la méthode clone.
Cette dernière peut être celle de Object ou une méthode fournie par X.
En fin, une tentative d’appel de clone sur une classe n’implémentant pas l‘interface
Cloneable conduit à une exception CloneNotSupportedException.
L’entête de clone est :
Object clone() ;
Cela signifie que son utilisation nécessite toujours un cast de son résultat dans le type
effectif de l’objet soumis à copie.
Une classe implémentant l'interface Cloneable doit réécrire la méthode clone(). La méthode
clone() doit retourner une copie de l'objet que l'on veut cloner. Cette copie dépend de la
classe de l'objet, cependant elle doit respecter des conditions (dont certaines par convention).
Pour un objet "clonable" x : l'expression

x.clone() != x
doit renvoyer true ;
l'expression
x.clone().getClass() == x.getClass()
doit renvoyer true (par convention) ;

l'expression
x.clone().equals(x)
doit renvoyer true (par convention).
Par convention, l'objet retourné doit être obtenu par un appel à la méthode
super.clone() .
Si une classe et toutes ses classes parentes (exceptée la classe Object) respectent
cette convention, alors l'expression
x.clone().getClass() == x.getClass()
renvoie bien true.
Par convention, l'objet retourné doit être indépendant de l'objet cloné, c'est à
dire que tous les attributs non immuables (unchangeable) devront être eux aussi
clonés.
3- Clonage Simple
Exemple : Création d'un objet Cellule suivi de son clonage
Soit la classe Cellule, constituée d'un entier et d'un tableau:
class Cellule extends Object implements Cloneable {
int i = 0;
int[] t = {1, 2};
public Object clone(){

try {
return super.clone();
}
catch (CloneNotSupportedException e){
throw new InternalError();
}
}
public void afficher(){

System.out.println(i +" "+ t[0]+" "+t[1]);
}
}

Tester cette classe avec:
class TestClone {
public static void main(String args[]){
Cellule x = new Cellule(); // x Objet Cellule

x.afficher();
Cellule y = (Cellule) x.clone(); // y clone de x
y.afficher();
}
}
et constater le résultat:
i=0 t=(1, 2) // valeurs de la cellule x

i=0 t=(1, 2) // valeurs de la cellule y
4- Clonage superficiel
En réalité, le clonage est superficiel. L'entier x.i a été copié dans y.i, mais pour le tableau t,
c'est la référence qui est copiée (non les éléments du tableau).
Pour le constater, rajouter à la classe Cellule une méthode qui change les éléments d'un
cellule.
Exemple : Rajouter à la classe Cellule la méthode
public void changeMe(){

i = 10;
t[0] = 11;
t[1] = 12;
}
et vérifier qu'en rajoutant dans main() les instructions:
x.changeMe();
x.afficher();
y.afficher();
on obtient:
i=10 t=(11, 12) // x change

i=0 t=(11, 12) // y aussi pour la partie tableau (même objet reference)
5- Clonage en profondeur
Pour copier tout l'objet Cellule, y compris le tableau, il faut cloner ce dernier. Pour cela On
change la méthode clone() de la classe Cellule, pour cloner le tableau.
public Object clone(){
try {
Cellule c = (Cellule) super.clone();
c.t = (int []) this.t.clone(); //clonage de this.t
return c;
}
catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
On crée par clonage une cellule temporaire c et on modifie son tableau c.t par
recopie ( this->t.clone() ).
Exercice
package TP_Clone;
public class Point implements Cloneable {
int x,y;
public Point ( int x,int y){
this.x = x;
this.y = y;
}
public Object clone() {

Object o = null;
try {
o = super.clone();
} catch(CloneNotSupportedException cnse) {
cnse.printStackTrace(System.err);
}
return o;
}
}

package TP_Clone;
public class Personne implements Cloneable {
public Personne (String prenom, String nom, Point p ) {

this.prenom = prenom;
this.nom = nom;
this.p = p;
}
public Object clone() {
Personne pr = null;
try {
pr = (Personne)super.clone();
} catch(CloneNotSupportedException cnse) {
cnse.printStackTrace(System.err);
}
pr.p = (Point) p.clone();
return pr;
}
String prenom;
String nom;
Point p;
}
package TP_Clone;
public class CloneTest {
public static void main(String []args) {
Point p = new Point(2,3);

Personne personne1 = new Personne("Jean", "Dupond", p);
Personne personne2 = (Personne) personne1.clone();
personne2.nom = "Ali";
personne2.p.x=22;
System.out.println(personne1.nom + " "+ personne1.prenom +
" " + personne1.p.x + " "+ personne1.p.y);
System.out.println(personne2.nom + " "+ personne2.prenom +
" " + personne2.p.x + " "+ personne2.p.y);
System.out.println(personne1.clone()!= personne1);
System.out.println(personne1.clone().getClass() ==
personne1.getClass());
}
}

************************************************

Chapitre 4 : Les tableaux d’objets
1- Introduction
Exercice 1: Test de niveau

Ecrire un programme java utilisant un tableau de flottants pour déterminer le nombre d’élève
d’une classe ayant une note supérieure à la moyenne de la classe.
import java.util.Scanner;
public class Moyenne {
public static void main (String arg[]){
int i, nbElement, nbSup;

double somme, moyenne;
Scanner sc = new Scanner(System.in);
System.out.print("Nombre d'éleves :");

nbElement = sc.nextInt();
double notes[] = new double[nbElement];
for (i = 0; i < nbElement; i++){

System.out.print("Note [" + i + "] = " );
notes[i] = sc.nextDouble();
}
for (i = 0, somme=0; i < nbElement; i++){
somme +=notes[i];
}
moyenne = somme/nbElement;
System.out.println(" La Moyenne = " + moyenne);
for (i = 0, nbSup=0; i < nbElement; i++){

if (notes [i] > moyenne) nbSup++;
}
System.out.println("Element > à la Moyenne=" + nbSup);
}
}

Exercice 2 : Tableau d’objets
Class Point { ………. }
Class TabPoint { ……… }
1- Créer un tableau de point,

2- Remplir ce tableau par des points,
3- Afficher le tableau.
public class Point {

this.x = x;
this.y = y;
}
public void affiche(){

System.out.println("x = " + x + " et y =" + y );
}
private int x,y;

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

Point [] tp;
tp = new Point [3];
tp[0] = new Point (1,2);
for(int i =0 ; i<tp.length; i++)
tp[i].affiche();
}

2- Tableau en argument ou en retour
Remarque
Length s’utilise comme s’il s’agit d’un attribut public de l’objet tableau (t.length) et
non comme une méthode (t.length()).
public class Util {
public static void raz (int t []){

for (int i = 0; i < t.length; i++)
t[i]=0;
}
public static int[] suite (int n) {

int [] resultat = new int[n];
for (int i=0; i<n; i++) resultat[i]= i+1;
return resultat;
}
public static void affiche(int t[]){

for (int i =0 ; i<t.length; i++)
System.out.print(t[i]+ ", ");
System.out.println();
}
public class TestTabArguement {
int t[] = {1,3,5,7,9};

Util.affiche(t);
System.out.println("******************");
Util.raz(t);
Util.affiche(t);
System.out.println("*******************");
int [] res;
res = Util.suite(10);
Util.affiche(res);
System.out.println("*******************");
}
}

Exercice 3
Soit Tpoint un tableau de points de dimension ‘n’.
1- Remplir le tableau avec des objets de types point

2- Afficher le tableau d’objet
3- Calculer le nombre d’objets Point qui se trouvent dans 4 zones du repère
xy.
Zone 1 (x>=0 et y>=0)
Zone 2 (x > 0 et y < 0)
Zone 3 (x < 0 et y > 0)
Zone4 (x<=0 et y<=0).

Chapitre 5 : L’héritage en orienté objet
1- Introduction
Classe Point ;
public class Point {

this.x = x;
this.y = y;
}
public void affiche(){

System.out.println("Point: x=" + x + " et y="+y);
}
private int x,y;

}
Classe PointCol extends Point

public class pointCol extends Point{
public pointCol (int x, int y , byte couleur){

super (x,y);
this.couleur = couleur;
}
public void afficheC(){
affiche();
System.out.println("Ma couleur est : " + couleur);
}
private byte couleur;

}
On dit que la classe pointCol est une classe dérivée de la classe point (classe de base)

Exemple
public class testPoitCol {
pointCol pc = new pointCol(5,6,(byte)10);

pc.affiche();
System.out.println("******************");
pc.afficheC();
}
Constatations
 Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa classe
de base.
 Cette règle peut paraitre restrictive mais en son absence, il suffirait de créer une
classe dérivée pour vider le principe d’encapsulation.
 La classe dérivée à accès aux membres public de sa classe de base.
2- Constructeur de la classe dérivée

En java, le constructeur de la classe dérivée doit prendre en charge l’intégralité de la
construction de l’objet dérivé, quitte à s’appuyer sur un appel explicite du
constructeur de la classe de base.
La classe de base ne possède aucun constructeur

Class A {
…………….// aucun constructeur
}
Class B extends A {
Public B(….) {
Super () ; // Appel du pseudo constructeur par défaut de A
……………
}
}

C’est pour s’assurer qu’un constructeur sans argument de la classe de base sera toujours appelé pour
que la partie ‘B’ héritée de ‘A’ sera donc convenablement initialisée.
La classe dérivée ne possède pas de constructeur

Dans ce cas la classe de base devra :
- Soit posséder un constructeur public sans argument, le quel sera alors appelé.
- Soit ne possède aucun constructeur, il y aura appel du pseudo-constructeur par
défaut.
Exemple 1
Class A {
Public A() { …………….}
Public A( int n ) { …………………….}
}
Class B extends A {
}
B b = new B() ; // appel du constructeur sans argument de A
Exemple 2
Class A {
Public A( int n ) { …………………….}
}
Class B extends A {
}
B b = new B() ;
Erreur !! A ne possède pas de constructeur sans argument.

Héritage (Suite)
Dérivation successives
D’une même classe peuvent être dérivées plusieurs classes différentes.
Les notions de classe de base et de classe dérivée sont relatives.
Sur-définition de méthodes
Méthodes de même nom, mais de signatures de différentes (dans la même classe).
Comment généraliser dans le cadre de l’héritage ?

Une classe dérivée pourra à son tour sur-définir une méthode d’une classe ascendante.
La nouvelle méthode ne deviendra utilisable que par la classe dérivée ou ses descendantes,
mais pas ses ascendantes.
Il s’agira non seulement de méthodes de même nom (cas de sur-définition) mais aussi de
même signature et de même type de valeur de retour.
Résumé
Sur-définition : cumuler plusieurs méthodes de même nom, Redéfinition : substituer une
méthode à une autre.
Exemple
Class Point { …… }
Class PointCol { ……. }
Class TestPointCol { ….. }
3- Redéfinition de méthodes et dérivation successive

Classe A : méthode f de A
Classe B : méthode f de A
Classe C : méthode f de C
Classe D : méthode f de D
Classe E : méthode f de A
Classe F : méthode f de C

4- Sur-définition et héritage
En Java, une classe dérivée peut sur-définir une méthode d’une classe de base.
Exemple
Class A {
Public void f (int n) { …… }
Class B Extends A {
Public void f(float x) { ….. }
Aa; Bb;
Int n ; float x ;
a.f(n); appel de f(int) de A,
a.f(x); Erreur !!!
b.f(n); appel de f(int) de A,
b.f(x); appel de f(float) de B,
5- Utilisation simultané de sur-définition et de redéfinition

(Cohabitation des deux concepts).
Exemple
Class A {
Public void f(int n) { ….. }
Public void f(float x) { …….. }

Class B extends A {
Public void f(int n) { ….. } Redéfinition de f(int n) de A
Public void f(double y) { …….. } Sur-définition de f de A et de B
Aa;Bb;
Int n ; float x ; double y ;
………………
a.f(n) ; appel de f(int) de A (mise en jeu de sur-définition dans A) ok
a.f(x) ; appel de f(float) de A (mise en jeu de sur-définition dans A) ok
a.f(y) ; Erreur !!!
b.f(n) ; appel de f(int) de B (mise en jeu de redéfinition de f dans B) ok
b.f(x) ; appel de f(float) de A (mise en jeu de sur-définition dans A et B) ok
b.f(y) ; appel de f(double) de B (mise en jeu de sur-définition dans A) ok
6- Contraintes portant sur la redéfinition
Exemple 1 : - Valeur de retour

Class A {
Public int f(int n) { ….. }
Class B extends A {
Public float f(float x) { ….. }
Sur-définir n’implique pas (le respecter le type de la valeur de retour),

Exemple 2
Class A {
Public int f(int n) { ….. }
Class B extends A {
Public float f(int n) { ….. } Erreur !!!!
Redéfinir impose non seulement l’identité des signatures mais aussi celle de la valeur de
retour.
La redéfinition d’une méthode ne doit pas diminuer les droits d’accès à cette méthode. En
revanche, elle peut les augmenter.
Le moins faible (private) ‘-‘ ---------------- le plus elevé (public) ‘+’
En passant par le droit d’accès (protected) ensuite (package =rien).
Remarque
Un membre déclaré protected est accessible à des classes du même package, ainsi qu’à ses
classes dérivées (quelles appartiennent au non au même package). Cette particularité
complique quelque peu la conception des classes, ce qui fait qu’en pratique, ce droit d’accès
est peu employé.

Chapitre 6 : Polymorphisme
1- Introduction
Il s’agit d’un concept extrêmement puissant en P.O.O. qui complète l’héritage, il
permet de manipuler les objets sans connaitre (tout à fait) le type.
Le polymorphisme exploite la relation "est" (en anglais IS-A) induite par l’héritage.
Exemple
Un point coloré est un point « on le traite comme un point mais l’inversion est
faut ».
“Polymorphism is the ability of an object to take on many forms. The most

common use of polymorphism in OOP occurs when a parent class reference is
used to refer to a child class object.”
“Any Java object that can pass more than one IS-A test is considered to be
polymorphic. In Java, all Java objects are polymorphic since any object will
pass the IS-A test for their own type and for the class Object.”
Résumé
Le polymorphisme en java se traduit par :
 La compatibilité par affectation entre un type classe et un type ascendant,

 La ligature dynamique des méthodes (liaison dynamique).

Chapitre 7 – Partie I : Les classes abstraites
1- Introduction
- Une classe abstraite est une classe qui ne permet pas d’instancier des objets.
- Elle ne peut servir que de classe de base pour une dérivation.
Abstract class A {
…………………
- Dans une classe abstraite, on peut trouver des champs et des méthodes, dont
héritera toute classe dérivée.
- Mais in peut trouver des méthodes dites abstraites (uniquement signature et
type de retour).
Abstract class A {
…………………
Public void f() { ……}
Public abstract void g (int n) ;
}
Peut-on déclarer une variable de type A ?

A a ; // ok mais toute instanciation sera rejeter par le compilateur,
// mais elle servir comme une référence sur un objet de type A.
A = new A(….); // Erreur
Class B extends A {
Public void g(int n) { …..} // Ici on définit g()
………………
}
A a = ne B(…..) ; // ok ça marche

 Dès qu’une classe comporte 1 ou plusieurs méthodes abstraites, elle est
abstraite,
 Une méthode abstraite doit obligatoirement être déclaré public,
 Une classe dérivée d’une classe abstraite peut être abstraite si elle ne définit
pas toutes les méthodes abstraites,
 Une classe dérivée d’une classe abstraite peut être abstraite et/ou contenir des
méthodes abstraites.
2- Intérêt des classes abstraites

- Les classes abstraites facilitent largement la conception orientée objet :
o Soit sous forme d’une implémentation complète de méthodes (non
abstraites) et de champs privés ou non) lorsqu’ils sont communs à
toutes ses descendantes,
o Soit sous forme d’interface de méthodes abstraites dont on est alors sûr
qu’elles existeront dans toute classe dérivée instanciable.
Exemple
Nous avons un classe abstraite nommée Affichable, dotée d’une méthode abstraite
affiche(). Deux classes Entier et Flottant dérivent de cette classe. La méthode main()
utilise un tableau hétérogène d’objets de type Affichable qu’elle remplit en
instanciant des objets de type Entier et Flottant. Afficher ensuite les objets de ce
tableau.

Chapitre 7 – Partie II : Les classes d’interfaces
1- Introduction
 Une classe abstraite permettait de définir dans une classe de base des
fonctionnalités communes à toutes ses classes descendantes, tout en leur
imposant de redéfinir certaines méthodes.
 Si l’on considère une classe abstraite n’implémentant aucune méthode et

aucun champ, on aboutit à la notion d’interface.
 En effet, une interface définit les entêtes d’un certain nombre de méthodes,
ainsi que des constantes. Les interfaces sont plus riches qu’un simple cas
particulier d’une classe abstraite.
Ainsi,
 Une classe pourra implémenter plusieurs interfaces alors qu’une classe ne

pourrait dériver qu’une seule classe abstraite,
 Les interfaces superposent la dérivation, mais ne la substitue pas,
 Les interfaces pourront se dériver,
 On pourra utiliser des variables de type interface.
2- Définition
Public interface I {
Void f(int n) ;
Void g() ;
}
Par essence, les méthodes d’une interface sont abstraites et publiques, néanmoins, il
n’est pas nécessaire de mentionner les mots clés public et abstract.

3- Implémentation
Public Class A implements interface I {

Void f(int n) { ………} ;
Void g() { ………}; // redéfinir f et g prévues dans l’interface I
}
Une même classe peut implémenter plusieurs interfaces.
Public interface I1 {
Void f(int n) ;
}
Void g() ;
}
Public Class A implements interface I1,I2 {
Void f(int n) { ………} ;
Void g() { ………}; // redéfinir f et g prévues dans les interfaces I1 et I2
}
4- Variable de type interface
Public interface I { …………. }

I i ; // i est une référence à un objet d’une classe implémentant l’interface I
Public Class A implements interface I { ……………. }
I i = new A(); // Ok
A travers i, on pourra manipuler des objets quelconques, pour peu que cette classe
implémente l’interface I.
Exercice
Refaire l’exercice Affichable de tableau avec polymorphisme en utilisant les interfaces.

5- Interface et classe dérivée
Public interface I1 { ………… }

Public interface I2 { ………… }
Public Class A implements interface I1 { ………….. }
Public Class B extends A implements interface I2 { ………….. }
6- Interface et classe dérivée
Public interface I {
Void f(int n) ;
Void g() ;
Static final int Max = 100;
}
Public Class A implements interface I {
// dans toutes les méthodes de A, on a accès au symbole Max
7- Dérivation d’une interface
Une interface peut être une généralisation d’une autre
Void f(int n) ;
Static final int Min = 20;
}

Public interface I2 extends I1 {
Void g() ;
Static final int Max = 100;
}
8- Conflit de noms
Première situation
Void f(int n) ;
Void g() ;
}
Void f(float x) ;
Void g() ;
}
Public Class A implements interface I1, I2 { …….. }
Dans cette situation nous avons deux méthodes f() et une seule méthode g() dans la
classe A.

Deuxième situation
Void f(int n) ;
Void g() ;
}
Void f(float x) ;
Int g() ;
}
Public Class A implements interface I1, I2 { …….. }
Dans cette situation la classe A ne peut implémenter à la fois I1 et I2.
9- Différences entre classes abstraites et classes d’interfaces
- Une classe abstraite permet de définir dans une classe de base des
fonctionnalités communes à toutes ses classes descendantes tout en leur
imposant de redéfinir certaines méthodes,
- Une classe pourra implémenter plusieurs interfaces alors qu’une classe ne

pourra dériver que d’une seule classe abstraite,
- Des classes différentes peuvent implémenter différemment une même classe

d’interface, alors que les classes dérivées d’une même classe de base
(abstraite) partagent la même implémentation,
- L’héritage multiple en java (est : l’utilisation des classes d’interfaces).

Chapitre 8 : Gestion des exceptions
1- Introduction
Le mécanisme d'exception est un mécanisme de déroutement du programme, c'est à dire
qu'elle brise la séquentialité du programme (comme le fait return, break, continue). Le
mécanisme qui brise la séquentialité est la levée d'exception. Lorsqu'une exception est levée,
le programme est dérouté vers les premiers gestionnaires d'exceptions.
Java dispose d’un mécanisme très souple nommé gestion d’exceptions qui permet à la fois :
1- De dissocier la détection d’une anomalie de son traitement,

2- De séparer la gestion des anomalies du reste du code.
Une exception est une rupture de séquence déclenchée par une instruction "throw"
comportant une expression de type classe.
Il y a alors un branchement à un ensemble d’instructions nommé "gestionnaire

d’exception".
Le choix du bon gestionnaire est fait en fonction du type de l’objet mentionné à "throw".
Exemple
Soit la classe Point avec un constructeur à deux (2) arguments et la méthode affiche.
On ne souhaite manipuler que les points ayant des coordonnés positives.

Public Point (int x , int y) throws ErrConst {
If (x < 0) || (y<0) throw new ErrConst () ; // lance une exception de type ErrConst
this.x = x;
this.y = y;
}
System.out.println( "je suis un point : " , + x + " " + y ) ;
}
Private int x, y ;
}
Class ErrConst extends Exception { …. }
La classe Exception est une classe standard,
Dans cette exemple c’est le constructeur qui d’éclanche une exception ErrConst.
Méthode de gestion des éventuelles exceptions de type ErrConst

1- Inclure dans un bloc « try » les instructions dans lesquelles on risque de voir déclencher
une telle exception.
Try {
// instructions
}
2- Faire suivre ce bloc de la définition des différents gestionnaires d’exception (ici un seul
suffit).
Ceci est notre gestionnaire unique ;
Catch (ErrConst e) {
System.out.println (" Erreur construction ") ;
System.exit (-1) ;
}
Ici le gestionnaire se contente d’afficher un message d’erreur et d’interrompre l’exécution

du programme (System.exit (-1) ).
Public classe Except1 {

Try {
Point a = new Point (1 , 4); a.affiche();
Point b = new Point (-3 , 4); b.affiche();
}
Catch (ErrConst e) { // Le gestionnaire d’exception
System.out.println (" Erreur construction ") ;
Clavier.lireInt(); // pour stopper la console et voir le message
System.exit (-1) ;
}
}
}
Dans cet exemple nous n’avons traité qu’un seul type d’exception.
2- Gestion de plusieurs exceptions

Soit la classe Point munie :
- Du constructeur, déclenchant toujours une exception ErrConst,

- D’une méthode déplace qui s’assure que le déplacement ne conduit pas à une
coordonnée négative.

Public void deplace (int dx , int dy) throws ErrDepl {
If (x+dx < 0) || (y+dy < 0) throw new ErrDepl () ;
x+ = dx;
y+ = dy;
}
Lors de l’utilisation de la classe point, nous pouvons détecter les deux exceptions
potentielles ErrConst et ErrDepl.
Try {
Point a = new Point (2 , 4); a.affiche();
Deplace(-3, 0);
Point b = new Point (-3 , 4); b.affiche();
}
System.out.println (" Erreur de construction ") ;
System.exit (-1) ;
}
Catch (ErrDepl e) { // Le gestionnaire d’exception
System.out.println (" Erreur de déplacement ") ;
System.exit (-1) ;
}
}
Class ErrConst extends Exception { …. }

Class ErrDepl extends Exception { …. }
Nous n’avons aucune chance de mettre en évidence celle qu’aurait provoquée la tentative de
construction du point b par l’appel de ( new Point( -3 , 4 ) )
3- Transmission d’information au gestionnaire d’exception

a- Par objet fourni à l’instruction throw

If (x < 0) || (y<0) throw new ErrConst ( x , y ) ;
this.x = x;
this.y = y;
}

System.out.println( "je suis un point : " , + x + " " + y ) ;
}
Private int x, y ;
}
Class ErrConst extends Exception {

ErrConst ( int abs , int ord ) {
this.abs = abs ;
this.ord = ord;
}
Public int abs, ord ;
}

System.out.println (" Erreur de construction ") ;
System.out.println (" Cordonnées souhaitées " + e.abs + " " + e.ord) ;
System.exit (-1) ;
}
b- Par le constructeur de la classe exception

Dans certains cas on peut se contenter de transmettre un message de type chaine au
gestionnaire d’exception.
La classe Exception dispose d’un constructeur à un argument de type String dont on peut
récupérer la valeur à l’aide de la méthode getmessage.

If (x < 0) || (y<0) throw new ErrConst ( " Erreur de construction avec
coordonnées + x + " " + y ) ;
this.x = x;
this.y = y;
}
}
Class ErrConst extends Exception {

ErrConst ( String mes ) {
Super(mes);
}
}

System.out.println ( e.getmessage () ) ;
System.exit (-1) ;
}
4- Mécanisme de gestion des d’exception

a- Poursuite de l’exécution
Dans les exemples précédents, le gestionnaire d’exception mettait fin à l’exécution du

programme « system.exit(-1) » cela n’est pas obligatoire ;
L’exécution peut se poursuivre après le gestionnaire d’exception.
b- Cheminement des exceptions
Le gestionnaire est rarement trouvé dans la méthode qui a déclenché l’exception puisque
l’un des objectifs fondamentaux du traitement d’exception est précisément de séparer le
déclanchement et le traitement d’une exception.
La clause throws
Toute méthode susceptible de déclencher une exception qu’elle se traite pas localement doit
mentionner son type dans une clause throws figurant dans son en-tête.
5- Les exceptions standards
Java fournit de nombreuses classes prédéfinies dérivées de la classe exception, qui sont
utilisées par certaines méthodes standard ;
Exemple
IOException et ses dérivées sont utilisées par la JVM à la rencontre de situations anormales
telles qu’un indice de tableau hors limites, une taille de tableau négative, …
Ces exceptions standard se classent en catégories :
1- Exceptions explicites (sous contrôle) correspond à ce que nous venons d’étudier.
2- exceptions implicites (hors contrôle)

N’ont pas à être mentionnées dans une clause throw et on n’est pas obligé de les
traiter.
Exemple d’exception standard
NegativeArraySizeException & ArrayIndexOutOfBoundsException
Public Class ExcStd {

Try {
Int T[];
System.out.println (" taille Voulue : " ) ;
Int n = clavier.lireInt () ;
T = new int [n] ;
System.out.println (" Indice : " ) ;
Int i = clavier.lireInt() ;
T[i] = 12 ;
System.out.println (" fin normale ") ;
}
Catch (Negative…… e) {
System.out.println (" Exception taille tableau négative :" +
e.getMessage() ) ;
}
Catch (ArrayIndex…… e) {
System.out.println (" ExceptionIndiceTableau :" +
e.getMessage() ) ;
}
}
}

Chapitre 9 : Les threads
1- Introduction
Un thread ou fil (d'exécution) ou tâche (terme et définition normalisés par ISO/CEI 2382-
7:2000 ; autres appellations connues : processus léger, fil d'instruction, processus
allégé, exétron, voire unité d'exécution ou unité de traitement) est similaire à
un processus car tous deux représentent l'exécution d'un ensemble d'instructions du langage
machine d'un processeur.
Du point de vue de l'utilisateur, ces exécutions semblent se dérouler en parallèle. Toutefois,

là où chaque processus possède sa propre mémoire virtuelle, les threads d'un même
processus se partagent sa mémoire virtuelle. Par contre, tous les threads possèdent leur
propre pile d'exécution.
Sur les machines monoprocesseur, la simultanéité, lorsqu’elle se manifeste, n’est en fait

qu’une illusion ; nous somme dans un environnement "passe la main" d’un programme à un
autre à des intervalles de temps suffisamment courts pour donner l’impression de la
simultanéité.
Java présente l’originalité d’appliquer cette possibilité de multiprogrammation au sein d’un

même programme dont on dit alors qu’il est formé de plusieurs threads indépendants. Ces
threads pourront facilement communiquer entre eux et partages des données.
Il y a deux façons de créer des threads :
a- Soit on exploitant la classe prédéfinie Thread,

b- Soit on créant une classe spécifique implémentant l’interface Runnable.
Aspects importants dans la manipulation des threads
 L’interruption des threads (threads démons)

 Coordonnées les actions de plusieurs threads
 Synchronisation,
 Gestion des attentes par des verrous sur un objet.
 Etat des threads,

 Comment agir sur la priorité d’un thread.
Première solution
En java un thread est un objet d’une classe qui dispose d’une méthode nommée run()
qui sera exécutée lorsque le thread sera démarré.
Class Ecrit extends Thread {

Public Ecrit (String texte, int nb) {
This.texte = texte;
This.nb = nb;
}
Public void run() {

For (int i=0; i<nb; i++)
System.out.print(text);
}
Private String texte;
Private Int nb;
}
Class test {
public static void main(String args []) {
// Création
Ecrit e1 = new Ecrit ("Bonjour", 10);
Ecrit e2 = new Ecrit ("Bonsoir", 12);
Ecrit e3 = new Ecrit ("\n", 5);
// Lancement
e1.start(); // lance le thread e1
// Arrêt d’un thread

Sleep(t); // t est exprimé en millisecondes
}
}
*************************************************
e1.start();
e2.start();
e3.start();
Clavier.lireInt();

Deuxième solution
Class Ecrit extends Thread {
Public Ecrit (String text, int nb, long attente) {

this.texte = texte;
this.nb = nb;
this.attente = attente;
}
Public void run() {

Try {
For (int i=0; i<nb; i++) {
System.out.print(texte);
Sleep(attente);
}
}
Catch (InterruptedException e) { ………} // impose par sleep()
}
Private Int nb;
Private Long attente;
}
Class testThread {

// Création
Ecrit e1 = new Ecrit ("Bonjour", 10, 5);
Ecrit e2 = new Ecrit ("Bonsoir", 12, 10);
Ecrit e3 = new Ecrit ("\n", 5, 15);
// Lancement
Clavier.lireInt();
}
}
Remarques
 Un programme comporte tjrs au moins un thread dit "thread principale" correspondant à

la méthode main(),

 La méthode start() ne peut être appliquer qu’une seule fois pour un objet thread donné.
 Sleep() est une méthode statique met en sommeil le thread encours d’excécution.
2- Utilisation de l’interface "Runnable"

Nous venons de voir comment créer des threads à partir de la classe Thread,
Cette démarche est simple mais elle présente une lacune,
- Les objets threads ne peuvent pas dériver d’autre classe que de threads,
Une deuxième démarche s’impose,
- Cette démarche est basée sur une classe implémentant l’interface runnable,
laquelle comporte une seule méthode nommée run().
Class Ecrit implements Runnable {

this.texte = texte;
this.nb = nb;
}
Public void run() {

Thread.sleep(t);
}
}
}
Nous serons amenés à créer des objets de type Ecrit,
Ces objets ne sont pas des threads et ne peuvent plus être lancées par la méthode start().

Nous devons créer des objets de type thread en utilisant une forme particulière de
constructeur recevant en argument un objet implémentant l’interface runnable.
Exemple
thread t1= new thread (e1);
// crée un objet thread associe à l’objet e1 qui doit implémenter l’interface runnable pour
disposer d’une méthode run(),
Nous lançons ensuite ce thread par start() ;
t1.start() ;
Class Ecrit implements Runnable {

this.texte = texte;
this.nb = nb;
}
Public void run() {

Try {
Thread.sleep(t);
}
}
Catch (InterruptedException e) {……} // imposé par sleep()
}

Private Int nb;
Private Long attente;
}
Class testThread {

// Création
Ecrit e2 = new Ecrit ("Bonsoir", 12, 10);
Ecrit e3 = new Ecrit ("\n", 5, 15);
// Lancement
t1.start() ;
t2.start() ;
t3.start() ;
}
}
3- Interruption d’un thread

Dans les exemples précédents, le threads s’achevaient tout naturellement avec la fin de
l’exécution de leur méthode run() (après 1 certains nombre d’appels de la méthode sleeps()).
Dans certains cas, on peut interrompre prématurément un thread depuis un autre thread. Ce
besoin est fondamental dans le cas de thread infinis.
Exemple :
Les threads de surveillance permettant à un thread d’interrompre un autre.
La méthode interrupt() de la classe thread demande à l’environnement de positionner un

indicateur signalant une demande d’arrêt du thread concerné (l’appel n’interrompre pas
directement le thread).

TOA Cours Version Finale

Transféré par

Informations du document

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

TOA Cours Version Finale

Transféré par

Droits d'auteur :

Formats disponibles

Techniques Objet Avancées

Exemple d’illustration : Les classes Point et TestPoint

Public classe Point {

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 1

Y=? Point a = new Point();

2- Mise en ouvre d’un programme comportant plusieurs classes

a- Un fichier source par classe

La machine virtuelle cherche une méthode main, parcontre dans un environ-nement

b- Plusieurs classes dans un même fichier source

Si Point est dans TestPoint là il faut supprimer Public de Point,

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 2

 Un appel obligatoire de ‘Initialiser()’ au moment opportun.

La notion de constructeur permet d’automatiser le mécanisme d’initialisation d’un

Point a = new Point() : ne convient plus

Public classe Point {

- Par essence un constructeur ne fournit aucune valeur de retour,

 Une initialisation par défaut de tous les champs de l’objet,

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 3

5- Méthodes de classes "Static"

6- Sur-définition de méthodes ‘surcharge/overload’

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 4

7- Sur-définition et droits d’accès

8- Transmission d’objets en argument

Public boolean coincide (Point pt) {

Pubic class TestCoincide {

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 5

Résolution du même problème avec une méthode static :

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 6

La définition de la classe I n’introduit pas d’office de membre de type I dans E.

En fait, la définition de I est utilisable au sein de la définition de E, pour l’instancier quand

Premier schéma d’utilisation de la classe interne I

Un objet de la classe E ne contient aucun membre de type I,

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 7

Ce sera par le constructeur de E ou par une méthode de E,…..

5- Une classe interne ne peut pas contenir des membres statiques.

La classe Centre possède un constructeur et une méthode affiche().

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 8

public class Cylindre {

public Cercle(int x, int y, double r) {

public void affiche() {

public void deplace(int dx, int dy) {

// ****************** End Cercle ******************

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 9

public void deplace(int dx, int dy) {

private Cercle c1, c2;

public class TestCylindre {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

Cylindre c = new Cylindre(x1,y1,x2,y2,r,h);

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 10

- En dehors de E, on peut tjrs déclarer une référence à un objet de type I :

E.I i ; // référence i interne à E

Si on dispose d’un objet e crée ainsi :

3- Classes internes locales

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 11

4- Classe Interne Statique

Depuis l’extérieur on peut instancier un objet de la classe I de cette façon :

E.I i = new E.I() ;

L’objet i n’est plus associé à aucun objet de type E,

Techniques Objet Avancées Pr. Abdelkrim Amirat Page 12

1- Introduction (copie d’un objet)

Public Point (int x, int y) { this.x = x ; this.y = y}

Public Point Copie () {

Point p = new Point (x,y);

// End Cercle