Niveau: 2ème Année GL/RT

Enseignante: Sana HAMDI

Email: sana.hamdi@fst.utm.tn
sanahamdi.fst@gmail.com
Chapitre1: Introduction à la programmation orientée objet
Chapitre2: Langage Java : Introduction et caractéristiques
Chapitre3: Notions de base Java
Chapitre4: Classes et Objets Java
Chapitre5: Héritage, Polymorphisme et Classes Abstraites
Chapitre 6: Les Interfaces
Chapitre 7: Les Exceptions

2
CHAPITRE4

3
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

4
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

5
 Une classe permet de modéliser des objets du monde Réel.
 Une classe permet de présenter des objets qui sont conceptuellement similaires.
 Les objets sont des instances de classe.
 Le mot class doit être écrit entièrement en minuscule

6
 Syntaxe:

[<modificateurs_de_classe>] class <nom_de_classe>

[extends <nom_de_superclasse>] [implements <interface_1>,<interface_2,...]
{
<Attribut_et_Méthodes>
}

7
 Exemple

class Point{
int x ; // abscisse du point Attributs
int y ; // ordonnée du point

void translater()
{
x=x+4;
y=y+4;
} méthodes
void afficher()
{
System.out.println("x="+x+" y="+y);
}
} 8
 détermine l’accessibilité de la classe par rapport
 Syntaxe:
aux autres classes

[<modificateur_de_classe>] class <nom_de_classe>

[extends <nom_de_superclasse>] [implements <interface_1>,<interface_2,...]
{
<Attribut_et_Méthodes>
}

9
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

10
Public package

La classe est accessible partout public

pa
class
point
public class Point {

int x ; // abscisse du point

int y ; // ordonnée du point
package2
}
package3 package4

pa
pa pa

11
Par défaut: package
Si aucun modificateur d'accès n'est déclaré, la classe sera
class
accessible par l'ensemble des classes et sous-classes situées pa
point

dans le paquetage parent mais en aucun cas, à l'extérieur de ce

dernier.
class Point {

int x ; // abscisse du point package2 package3 package4

int y ; // ordonnée du point

} pa pa pa

12
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

13
Déclaration
 La déclaration d’une instance d’une classe se fait de la façon
similaire à la déclaration d’une variable:
<class_name> nom_instance;
 Exemple:
Point p;
Déclare une instance p de la classe Point

14
Instanciation:
L’opérateur new instancie une classe par:
 Allocation de mémoire pour le nouvel objet
 Retour d’ une référence à cette mémoire.

L’opérateur new invoque le constructeur de l'objet

Point p = new Point(23,94);

15
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

16
Définition
 Un constructeur est une méthode qui porte le même nom que la classe sans
valeur de retour et qui peut disposer d’arguements.
 Le constructeur permet de:
 allouer de la mémoire pour l’objet
 initialiser les attributs de l’objet

 Exécution d’un constructeur à travers le mot clé new

17
 Exemple :
public class Point {
int x; // x: abscisse du point
int y; // y: ordonnée du point
public Point(int a, int b){
x=a; y=b;}
public double distance(Point p){
return(Math.sqrt((Math.pow(x-p.x,2)+Math.pow(y-p.y, 2))));}

public void translater(int dx, int dy){

x=x+dx; y=y+dy; }
}

18
 Suite Exemple :

public class TestPoint {

public static void main(String args[]){
Point p=new Point(2,5);
p.translater(2, 2);
System.out.print("x="+p.x+"y="+p.y);
}

19
 Si aucun constructeur n’est défini, java offre pour chaque classe un
constructeur par défaut, implicite et sans arguments qui instancie
par défaut les attributs:
 entiers et réels à 0
 Objets à null
 boolean à false

Si on définit un constructeur, le constructeur par défaut ne peut plus être appelé

20
 Exemple :
public class Point {
int x; // x: abscisse du point
int y; // y: ordonnée du point
public Point(int a, int b){
x=a; y=b;}
public double distance(Point p){
return(Math.sqrt(Math.pow(x-p.x,2)+Math.pow(y-p.y, 2))));}

public void translater(int dx, int dy){

x=x+dx; y=y+dy; }
}

21
 Suite Exemple :

public class TestPoint {

public static void main(String args[]){
Point p1=new Point(); // Erreur de compilation
Point p2=new Point(2,5);
p2.translater(2,2);
System.out.print("x="+p2.x + "y="+p2.y);
}

22
 Une classe peut avoir plusieurs constructeurs qui diffèrent par le nombre et la nature de
leurs paramètres: possibilité d'initialiser un objet de plusieurs manières différentes

 Exemple:
public class Point {
int x; // x: abscisse du point
int y; // y: ordonnée du point
public Point(int a, int b){x=a; y=b;}
public Point( ){} deux constructeurs
public double distance(Point p){
return(Math.sqrt((Math.pow(x-p.x,2)+Math.pow(y-p.y,2))));}

public void translater(int dx, int dy){

x=x+dx; y=y+dy; }
}
23
 Suite Exemple:

public class TestPoint {

public static void main(String args[]){
Point p1=new Point();
Point p2=new Point(2,5);
p2.translater(2,2);
System.out.print("x="+p2.x + "y="+p2.y);
}

24
 Le mot clé this représente une référence sur l’objet courant (celui qui est entrain
d’exécuter la méthode contenant le this).
 La référence this peut être utile :

 Lorsqu’une variable locale ou paramètre d’une méthode porte le même nom

qu’un attribut de la classe.
 Pour déclencher un constructeur depuis un autre constructeur

25
 Exemple

class Date {
int jour=1, mois=1, an=1990;
Date(){
an=2000;} // peut s’écrire : this.an=2000
Date(int an){
this.an=an;} // le paramètre en cache l’attribut an
Date(int an, int mois, int jour){
this(an); // Appel du deuxième constructeur
this.jour=jour;
this.mois=mois;
}
}

26
 Le mot clé null permet de représenter la référence qui ne représente rien.

 On peut assigner cette valeur a n’importe quelle variable ou attribut contenant une

référence.

 C’est aussi la valeur par défaut d’initialisation des attributs représentant des références.

class Test{
Voiture v1; //initialisation a null par défault.
void methode(){
…
if (v1==null) v1 = new Voiture();
…
}
}
27
 Les variables de type objet que l'on déclare ne contiennent pas un objet mais une
référence vers cet objet.
 Création d’une copie d'un objet : avec l’opérateur "="

Personne p1 = new Personne();

Personne p2 = p1;

 p1 et p2 contiennent la même référence et pointent donc tous les deux sur le

même objet : les modifications faites à partir d'une des variables modifient
l'objet.

28
 Création d’une copie d'un objet : la méthode clone() :
 Cette méthode permet de créer un deuxième objet indépendant mais identique
à l'original.
 Cette méthode est héritée de la classe Object qui est la classe mère de toutes
les classes en Java.

Personne p3 = new Personne();

Personne p4 = p3.clone();

 p3 et p4 ne contiennent pas la même référence et pointent donc sur des objets

différents.

29
 L'opérateur "==" compare les références de deux objets.

 Deux objets avec des propriétés identiques sont deux objets distincts.
 la méthode equals (Object o) héritée de la classe Object peut être redéfinie pour
comparer l'égalité des variables de deux instances.
 Par défaut (sans redéfinition), la méthode renvoie ‘’true’’ si les 2 objets ont les mêmes
références
Personne P1 = new Personne ("Foulen","Ben Foulen", 25, 1.85 );
Personne P2 = new Personne ("Foulen","Ben Foulen", 25, 1.85 );
if (P1 == P1) { ... } // vrai
if (P1 == P2) { ... } // faux
if (P1.equals(P2)) { ... } // faux si pas de redéfinition

30
 gc: Le Garbage Collector ou ramasse-miettes est chargé de détecter les objets

devenus inaccessibles

 La récupération de mémoire peut alors être invoquée explicitement par le

programmeur à des moments bien précis avec la méthode System.gc ( )

31
  En A, ni 1 ni 2 ne
Compte Tab [ ] = new Compte[3];// 1 peuvent être GC, car
Compte c1 = new Compte( ); // 2 Tab et c1 sont toujours
référencés
Tab[0] = c1;
System.gc( ); //A
Tab[1] = new Compte( ) ;//3  En B, 1 peut être libéré,
ainsi que 3 par voie de
Tab=null; conséquence.
System.gc(); //B
c1=null;
 En C, 1, 2 et 3 peuvent
System.gc(); //C être libéré.

32
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

33
Définition
 On désigne par membres d’instance les attributs et les méthodes
non statiques qui ne sont accessibles qu’à partir d’une instance de
classe (objet).
 L’accès aux membres nécessite l’instanciation de la classe les
contenant.
 La valeur d’un attribut d’instance est différente pour chaque
instance

34
Exemple :

public class Personne{

String Nom;
public Personne(String n){ Membres d’instances
Nom=n;}
public void afficher(){
System.out.println("Je m’appelle "+ Nom);
}}

35
 l’accès aux membres se fait par un « . » précédé par le nom de l’instance

public class TestPersonne {

public static void main(String args[]){
Personne P1 = new Personne (" Ahmed");
Personne P2 = new Personne (" Asma");
P1.afficher();
P2.afficher();
}}

36
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

37
 Un membre (attribut ou méthode) déclaré avec le modificateur static est un
membre de classe.
 Les attributs statiques sont communs à toutes les instances de classe

 Les attributs statiques sont initialisés par défaut à 0 pour les nombres entier et
réels, à false pour les booléens et à null pour les références.

 Une méthode de classe ne peut utiliser que les attributs et les méthodes statiques
et ne peut pas faire référence à l'objet courant ( this)
 Il n’est pas nécessaire d’instancier une classe pour accéder à un des membres
statiques. On peut y accéder sans création d’instance de la classe.
NomClasse.membre

38
Exemple
public class Personne{
String Nom;
static int nbPersonne;
public Personne(String n){Nom=n; NbPersonne ++;}
public void afficher(){
System.out.println("Je m’appelle "+ Nom);
}
}

public class TestPersonne {

public static void main(String args[]){ Accéder
Personne P1 = new Personne (" Ahmed"); directement à
partir de la classe
Personne P2 = new Personne (" Asma");
System.out.println(Personne.nbPersonne);
}
} 39
Exemple:
La méthode plus
est définie static

public class Cercle{

public double x,y,r; méthode d’instance
public Cercle bigger(Cercle c){
if (c.r > r) return c
else return this; }
public static Cercle bigger(Cercle a, Cercle b){
if (a.r > b.r) return a
else return b; }
} méthode de classe
Cercle c = Cercle.bigger(a, b);
40
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

41
 Les classes peuvent être organisées dans une structure de paquetage
 package (java,…)
 namespace (c++,…)

 Les packages sont des répertoires pour les fichiers

 Les classes peuvent être regroupées en paquetages imbriqués
 Il est indispensable, lors de leur utilisation, soit de spécifier leur nom
complet (nompackage.nomclasse) soit d’indiquer au début le package qui
doit être utilisé (import et using)

42
43
44
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

45
 public : Un membre public est visible par les membres qui sont hors de sa portée,
tant que la classe parent est visible.

 private : L’accès à un membre privé est limité à la classe de ce membre

 protected : Un membre protégé peut être accédé par les autres membres de sa
classe et par les membres des classes du même paquet et aussi par des classes
filles (qui héritent de la classe parente) hors paquet.

 Si aucun modificateur d’accès n’est déclaré, le membre est disponible pour toutes
les classes se trouvant dans le paquet parent, mais pas à l’extérieur du paquet.

46
Modificateur classe package Sous-classe Autres
packages
public oui oui oui oui
protected oui oui oui non
oui oui non non
private oui non non non

47
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

48
 Plusieurs méthodes peuvent porter le même nom dans une même classe

 Les méthodes doivent différer par le nombre des arguments, ou par le type des
arguments

 Les constructeurs multiples est un cas particulier de surcharge

 Le compilateur ne peut distinguer deux méthodes se différenciant uniquement

par leur type de retour

49
 Plusieurs méthodes peuvent porter le même nom dans une même classe

 Les méthodes doivent différer par le nombre des arguments, ou par le type des
arguments

 Les constructeurs multiples est un cas particulier de surcharge

 Le compilateur ne peut distinguer deux méthodes se différenciant uniquement

par leur type de retour

50
class Rectangle {
void doubler() {
largeur*=2;
hauteur*=2; }
void doubler(boolean l, boolean h){
if (l) largeur*=2;
if (h) hauteur*=2;}
}

class TestRecDisk{
public static void main (String arg[]) {
r.doubler(); // largeur et hauteur
r.doubler(false, true); // uniquement la //hauteur
}
51
Exercice:
1. Définissez une classe Point qui surcharge le constructeur comme suit:
 créer un objet Point dont les coordonnées sont égaux à 0.
 créer un objet Point dont les coordonnées sont initialisés à un entier donné en
paramètres.
 créer un objet Point dont les coordonnées sont initialisés avec deux valeurs données en
paramètres
 créer un objet Point dont les coordonnées sont identiques à ceux d’un autre objet Point
donné en paramètres.
2. Créer la classe TestPoint qui permet de tester la classe Point.

52
PLAN DU CHAPITRE 4
1. Classe
2. Modificateurs de classe
3. Objet
4. Constructeurs
5. Membres d’instances
6. Membres de classe
7. Le packetage
8. Les modes d’accès
9. La surcharge
10. Les accesseurs et les mutateurs

53
 Les accesseurs : méthodes pour récupérer la valeur d'une variable (« getters »)
 Nom de la méthode commence par get
 Retourne la valeur d'une variable d'instances ou de classe
 Type du retour = type de la variable accédée

 Les mutateurs : méthodes pour modifier la valeur d'une variable (« setters »)

 Nom de la méthode commence par set
 Modifie directement la valeur d'une variable d'instances ou de classe
 Type du retour = void

 Pour pouvoir être appelés depuis « l'extérieur », les accesseurs et mutateurs

doivent être des méthodes publiques

54
public class Point{
private double x ;
private double y ; //Variables d'instance
public Point(){ this(0,0) ; } //Constructeur par défaut
public Point(double x, double y){ this.setX(x); this.setY(y);} //Constructeur avec arguments
public double getX(){ return this.x ; }
public void setX(double x){ this.x = x ; } //Accesseurs à la variable x.
public double getY(){ return this.y ; }
public void setY(double y){ this.y = y ; } //Accesseurs à la variable y.

55
Merci pour votre attention !

Dr. Sana Hamdi

Maitre Assistante en Informatique à l’INSAT

Membre du Laboratoire LIPAH (FST-Tunisie)

et du Laboratoire SAMOVAR (Telecom SudParis-France)