CHAPITRE III

PROGRAMMATION ORIENTEE OBJET

(POO)

1
 Concept de Classe
Une classe est la description d’un ensemble de données et de
fonctions regroupées au sein d’une même entité (appelée
objet).
On peut définir une classe comme étant aussi une description
abstraite d’un objet du monde réel.
Objet est défini par
◦ une identité
◦ un état
◦ un comportement
Les fonctions qui agissent sur les données de l’objet sont aussi
appelées méthodes.

2
 Concept de Classe
La méthode est accessible depuis Les champs x et y ne sont visibles qu'à
n’importe quel programme. L’intérieur de la classe principe de
l’encapsulation des données. Les données
public class Point ne seront accessibles que par
l’intermédiaire de méthodes prévues à cet
{ effet.
private int x ; // champ x d’un objet Point
private int y ; // champ y d’un objet Point
public void initialise ( int abs, int ord )
{ x = abs ;
y = ord ;
} Permet d’attribuer des valeurs
Une méthode qui ne
} fournit aucun résultat: initiales aux champs de l’objet.
.
→ void
3
 Remarque
Une méthode peut être déclarée private : dans ce cas
elle n’est visible qu’à l’intérieur de la classe où elle
est définie. Pour pouvoir l’utiliser dans un autre
programme, il faut nécessairement passer par une
méthode publique de sa classe ayant l’appelée.

Il est fortement déconseillé de déclarer des champs

avec l’attribut public , cela nuit à l’encapsulation des
données.

4
 Création d’objet
int a = 10 ;
float x ;
Point a ; /* cette déclaration ne réserve pas d’emplacement pour un objet de
type Point mais simplement une référence à un objet de type Point. */
La création d’un objet (on parle d’instanciation ) se fait avec l’opérateur
new :
new Point ( ) ; /*crée un emplacement pour un objet de type Point et
fournit sa référence comme résultat*/
on pourra écrire :
a= new Point ( ) ; /*crée un objet de type Point et on met sa référence
dans la variable a*/
a X
Y

Objet
point 5
 Manipulation d’objet
Une fois qu'une référence à un objet est convenablement
initialisée, on peut appliquer n’importe quelle méthode à l’objet
correspondant.

a.initialise ( 2,4 ) ;
Operateur d’accès

6
 Programme de test
class Point01
{
private int x ;
private int y ;
public void initialise ( int abs, int ord )
{ x = abs ;
y = ord ;
}
}
public class TestPoint01
{ public static void main( String args [ ] )
{ Point01 a = new Point01 ( ) ;
a.initialise( 10,12 ) ;
}
}

7
 Constructeur
En Java, la création d’objet se fait par allocation dynamique grâce
à l’opérateur new qui appelle une méthode particulière : le
constructeur.
En fait un constructeur permet d’automatiser l’initialisation d’un
objet.

Un constructeur est une méthode qui porte le même

nom que le nom de la classe et qui est sans valeur de
retour. Il peut disposer d’un nombre quelconque
d’arguments.

8
 Constructeur
class Point02
{
private int x ;
private int y ;
public Point02 ( 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("Point de coordonnées" + x + " et " +y);
}
}
9
 Constructeur
public class TestPoint02
{ public static void main( String args [ ] )
{ Point02 a = new Point02 ( 10, 12 ) ;
a.affiche( ) ;
a.deplace( 10,12 ) ;
a.affiche( ) ;
}/

10
 Règles sur les constructeurs
Une classe peut disposer de plusieurs constructeurs: ils se différencieront par le nombre et le type
de leurs arguments.

Une classe peut ne pas disposer de constructeur; dans ce cas on peut instancier des objets comme
s’il existait un constructeur par défaut sans arguments et ne faisant rien.

Mais dès qu’une classe possède au moins un constructeur, ce constructeur par défaut ne peut plus
être utilisé, dans le dernier exemple on ne pouvait pas faire :
Point a = new Point ( ) ;// incorrect s’il y’a un constructeur

Une classe peut disposer d’un constructeur sans arguments qui est bien différent du constructeur par
défaut (appelé souvent pseudo-constructeur).

Un constructeur peut appeler un autre constructeur de la même classe (A VOIR).

Un constructeur peut être déclaré public ou privé.

11
 Affectation et comparaison d’objets
.Affectation

Point a ; 12
10
a = new Point (12,10 ) ;
a
11
Point b = new Point ( 11, 14 ); 14
b
affectation d’objet 12
a=b; a 10

Sera candidat au 11
ramasse-miettes b
14
s’il n’est plus référencé

12
 Affectation et comparaison d’objets
●Comparaison
L'opérateur d'égalité = = , détermine si deux objets String spécifiés ont la même
référence et non la même valeur, il ne se comporte pas en Java comme sur des
éléments de type de base (int, char,...)
String a , b ;
(a = = b ) renvoie true si les variables a et b référencent chacune le même objet de
chaîne sinon il renvoie false.
La méthode boolean equals(Object s) teste si deux chaînes n'ayant pas la même
référence ont la même valeur.
String a , b ;
a.equals ( b ) renvoie true si les variables a et b ont la même valeur sinon il
renvoie false.
En d'autres termes si nous avons deux variables de String ch1 et ch2, que nous
ayons écrit ch1 ="abcdef"; et plus loin ch2 = "abcdef"; les variables ch1 et ch2
n'ont pas la même référence mais ont la même valeur (valeur = "abcdef").

13
 Affectation et comparaison d’objets
Exemple
String s1,s2,s3,ch;
ch = "abcdef";
s1 = ch;
s2 = "abcdef";
s3 = new String("abcdef".toCharArray( ));
if( s1 == ch ) System.out.println ("s1=ch");
else System.out.println ("s1<>ch");
if( s1 == s3 ) System.out.println ("s1=s3");
else System.out.println ("s1<>s3");
if( s1.equals(s2) ) System.out.println ("s1 même val. que s2");
else System.out.println ("s1 différent de s2");
if( s1.equals(s3) ) System.out.println ("s1 même val. que s3");
else System.out.println ("s1 différent de s3");
if( s1.equals(ch) ) System.out.println ("s1 même val. que ch");
else System.out.println ("s1 différent de ch");

14
 Champs et méthodes de classe:
le mot clé static .

Les champs de classe ou champs statiques existent en un seul exemplaire

Pour toutes les instances de la classe. On les déclare avec le mot clé static .

public class ChampStatic ChampStatic a = new ChampStatic( ) ;

{ ChampStatic b = new ChampStatic( ) ;
int n ;
static int k ; a.n b.n
}
a.k b.k

a.k et b.k peuvent être remplacés par ChampStatic.k .

15
 Exemple
public class ChampStatic {
private static int nb;
public ChampStatic()
{ nb++;
}
public void affiche()
{
System.out.println ("nombre d’objets créés :" + nb );
}
public static void main (String args[])
{ ChampStatic a = new ChampStatic ( );
a.affiche ( );
ChampStatic b = new ChampStatic ( );
b.affiche ( );
}
}

16
 Méthode static

Une méthode d’une classe ayant un rôle indépendant de toute

instance de la classe doit être déclarée avec le mot clé static
et elle ne pourra être appliquée à aucun objet de cette classe,
contrairement aux méthodes d’instances.
L’appel de la méthode ne nécessitera que le nom que de la
classe.
Une méthode statique ne peut pas agir sur des champs usuels, c’est-à-
dire non statiques.

17
 Exemple
public class MethodeStatic {
private long n;
private static long nombreInstanceCrees;
public MethodeStatic( long k)
{ nombreInstanceCrees++ ;
n=k;
}
public void affiche ( )
{
System.out.println ("nombre d’objets créés :" + nombreObjet( ) );
}
public static long nombreObjet( )
{ return nombreInstanceCrees;
}
}

18
 Surdéfinition de méthodes

La surdéfinition de méthodes signifie qu’un même

nom de méthode peut être utilisé plusieurs fois dans
une même classe . Dans ce cas, le nombre et/ou le
type des arguments doit nécessairement changé.

19
 Exemple1

public class Surdef1{

private int x ,y;
public static void main(String[]
public Surdef1 (int abs, int ord )
args) {
{ x=abs; y=ord; }
Surdef1 ex = new
public void deplace (int dx, byte
Surdef1(10,10);
dy)
ex.deplace ( 10 );
{ x += dx ; y += dy ; }
ex.affiche ( );
public void deplace (byte dx )
ex.deplace( 10, 10 );
{ x += dx ;}
ex.affiche( );
public void affiche()
}
{
}
System.out.println(" Point de
coordonnees :"+ x+ " "+y);}

20
 Exemple2(En cas d’embiguïté)

public class Surdef1{

private int x ,y; public static void main(String[] args)
public Surdef1 (int abs, int ord ) {
{ x=abs; y=ord; } Surdef1 ex = new Surdef1(10,10);
public void deplace (int dx, byte int n; byte b;
dy) ex.deplace (n,b );
{ x += dx ; y += dy ; } ex.affiche ( );
public void deplace (byte dx ,int ex.deplace( b,n );
dy) ex.affiche( );
{ x += dx ;} ex.deplace(b,b);
public void affiche() }
{ }
System.out.println(" Point de
coordonnees :"+ x+ " "+y);}

21
 Surdéfinition de constructeurs
Public class Point
{ private int x, y ;
public Point( )
{x=0;y=0;} public static void main (String args[])
public Point( int abs ) { Point a=new Point();
{x=y=abs;} a.affiche();
public Point( int abs, int ord ) { Point b=new Point(5);
{ x = abs ; y = ord ; } b.affiche();
public void deplace (int dx, int dy )
{ x += dx ; y += dy ; { Point c=new Point(3,9);
} c.affiche();
public void affiche( )
{ System.out.println("Point de
coordonnées" + x + " et " +y);
}
}
22
 Transfert d’informations
avec les méthodes
Cette transmission a des conséquences totalement
différentes, selon que l’on manipule des types primitifs ou
bien des types objet ( c-à-d des références).

Transmission par valeur : la méthode reçoit une copie de la valeur

de l’argument effectif sur laquelle elle travaille. Pas de possibilité
d’agir sur la valeur de l’argument effectif.
Transmission par référence ( par adresse): la méthode reçoit
l’adresse de l’argument effectif sur laquelle elle travaille
directement. Ici, possibilité de modifier donc la valeur de
l’argument effectif.

23
 Mécanisme de transmission

public class TrV {

private double res;
public TrV(double n) { Argument muet
res = n;
}
public double add ( double p )
{
return res += p;
} 10
public static void main(String[] args) {
TrV tv = new TrV(12);

System.out.println ( tv.add ( 10 ) );
10
}

Argument effectif

24
 Mécanisme de transmission
public class Point {
private int x;
private int y;
public Point (int abs, int ord) {
x = abs;
y = ord;
} Référence à un objet de type
public boolean coincide ( Point p) Point transmise en argument
{ d’une Méthode.
return ( p.x == x && p.y == y);
}
p
public static void main (String [ ] args) {
Point a = new Point(10,12); 12
Point b = new Point(12,12);
System.out.println( a.coincide ( b ) );
12
}}
b
10
a 12

25
 Autoréférence : this

Dans un appel de la forme a.coincide( b ), la méthode reçoit une information lui

permettant d’identifier l’objet ayant fait l’appel. Si l’information est transmise, la
méthode pourra agir sur les champs spécifiques de l’objet.
Cette transmission est gérée automatiquement par le compilateur.
Mais on peut vouloir agir sur l’objet globalement au lieu d’agir sur les champs.
Dans ce cas Java utilise le mot clé this. Dans l’exemple précédent, on peut
remplacer la méthode coincide par celle-ci:

public boolean coincide ( Point p)

{ // this reference ici l’objet courant ie celui ayant fait l’appel de coincide
return ( p.x == this.x && p.y == this.y);
}
Dans un appel a.coincide (b) a désigne l’objet courant.

26
 Autoréférence : this

L’utilisation de this est très pratique dans l’écriture des méthodes et

surtout des constructeurs.

public Point ( int abs, int ord ) { public Point ( int x, int y ) {
x = abs; this.x = x;
y = ord; this.y = y;
} }

27
 Les packages
Un package regroupe un ensemble de classes sous un même espace de nommage.
Les noms des packages suivent le schéma : name.subname…
Une classe Watch appartenant au package time.clock doit se trouver
obligatoirement dans le fichier time/clock/Watch.class.
Les packages permettent au compilateur et à la JVM de localiser les fichiers
Contenant les classes à charger.
L’instruction package indique à quel paquetage appartient la ou les classe(s) de
l’unité de compilation (le fichier).
En dehors du package, les noms des classes sont: packageName.className.
L’instruction import packageName permet d’utiliser des classes sans les
préfixer par leur nom de package.
Les API sont organisées en package (java.lang, java.io, javax.swing,….)

28
 Droits d’accès et paquetage

En Java, il y a quatre types de droits aux méthodes et aux champs d’un objet d’une
classe. Autrement dit, la portée de la visibilité des méthodes et champs est assurée
par les mots clés: private, protected, vide (droit de paquetage), et public.

Nous décrivons ici, la notion de droit d’accès parallèlement à la notion de

paquetage.
Nous séparerons la visibilité des champs et celle des méthodes.

29
 Paquetage et encapsulation

class c1{
class c4 extends c1{
public int a;
…. a c
int b;
}
protected int c;
private int d; }

package B
package A
class c2 extends c1{ class c3 { class c5 {
a bc a bc a
…… …. …..
} } }

30
 Accés au membre

package graph.2D; package graph.3D;

public class Circle{ public class Sphere{
….. …..
} }

package testpackage;
import graph.2D.*;
public class MainClass{
public static void main (String args []){
graph.2D.Circle c1= new graph.2D.Circle(50);
Circle c2 = new Circle (80);
graph.3D.Sphere s1 = new graph.3D.Sphere (100);
Sphere s2 = new Sphere (50);}

31
 Accés au membre

class c1{
class c4 extends c1{
public void f( );
…. f( ) h( )
void g( ); f( ) h( )
}
protected void h( );
private void k( ); }

package B
package A
class c2 extends c1{ class c3 { class c5 {
f( ) g( ) h( ) f( ) g( ) h( ) f( )
…… …. …..
} } }

32