Chapitre III :

Classes et Objets en JAVA

A.Hammache 1
Plan du Chapitre

Rappels

Classe

Méthodes

Objets

Encapsulation

A.Hammache 2
 L’approche objet
Un objet informatique
 maintient son état dans des variables (appelées champs)
 implémente son comportement à l'aide de méthodes

objet informatique = regroupement logiciel de variables

et de méthodes
Cycle de vie d’un objet
1. Construction (en mémoire)
2. Utilisation (changement d’état par exécution de méthodes)
3. Destruction

3
 Déclaration d’une classe
Le nom de la classe est spécifié derrière le mot clé « class »
Le corps de la classe est délimité par des accolades {}
On définit dans le corps les champs et les méthodes qui constituent la classe
Modificateurs class Nomclasse {
< corps de la classe >
Champs
Méthodes
}
Modificateur Rôle
abstract la classe contient une ou des méthodes abstraites, qui n'ont pas de définition explicite.
Une classe déclarée abstract ne peut pas être instanciée : il faut définir une classe qui
hérite de cette classe et qui implémente les méthodes nécessaires pour ne plus être
abstraite.
final la classe ne peut pas être modifiée, sa redéfinition grâce à l'héritage est interdite. Les
classes déclarées final ne peuvent donc pas avoir de classes filles.
public La classe est accessible partout
par défaut : Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par défaut
package lorsqu'aucun modificateur n'est précisé. Cette déclaration permet à une classe d'être
visible par toutes les classes se trouvant dans le même package.
 Syntaxe de définition d’une classe

public Class Point Nom de la Classe

{
double x; // abscisse du point
double y; // ordonnée du point Attributs
// translate de point de (dx,dy)
void déplacer(double dx, double dy) {
x = x+dx;
y = y+dy; Méthodes
}
// calcule la distance du point à l’origine
double distance() {
return Math.sqrt(x*x+y*y);
}
}
 Conventions pour les identificateurs
Classes : tous les mots commencent par une lettre majuscule
 exemple: Point, PointColoré, Personne, Etudiant, System, etc.

Variables : comme pour les classes, mais le premier mot commence

par une lettre minuscule (ex : nom, nomPersonne)

Constantes : en majuscule avec les mots séparés par le caractère

souligné (ex. : UNE_CONSTANTE)

Méthodes : comme pour les variables, mais le premier mot est un

verbe (ex. : afficherSomme, calculerPrix, getNom, setNom)

6
 Déclaration des champs

public, private, protected, package type du champ Identificateur du champ

static, final, …………

<modificateur> <type> <nomChamp> ;

public class Point {

// Champs de la classe Point
private double x;
private double y;
}
 Déclaration des méthodes

public, private, protected, package type de la valeur couple d'un type et d'un
static, final, abstract renvoyée ou void identificateur séparé par des « , »

<modificateur> <type-retour> <nomMéthode> (<liste-param>)

{
<bloc>
}

public void déplacer(double dx, double dy) { public double distance() {

x = x+dx; return Math.sqrt(x*x+y*y);
y = y+dy; }
}
 Méthodes particulières
Méthodes Rôle
Constructeur Un constructeur est une méthode qui permet l’instanciation des objets à
partir d’une classe et l’initialisation des champs de ces objets. Un
constructeur a le même nom que la classe et sans type de retour.
Méthodes d’accès Méthodes qui retourne l’état d’un objet (certains champs) qui sont
(getter) généralement privés .
La notation utilisée est getXXX ; XXX le champs retourné
Méthodes de Méthodes qui modifie l’état d’un objet (certains champs).
modification (setter) La notation utilisée est setXXX ; XXX le champs modifié

Class Point // méthode qui permet de retourner la //valeur de y

{ double getY() {
double x; // abscisse du point return y;
double y; // ordonnée du point }
// constructeur // méthode qui permet de modifier la //valeur de y
Point ( double dx, double dy){ void setY(double dy) {
x=dx; y=dy;
y=dy; }
} }
 Surcharge de méthodes
 Dans une même classe, plusieurs méthodes
peuvent posséder le même nom, pourvu qu'elles
diffèrent en nombre et/ou type de paramètres.
– On parle de surdéfinition ou surcharge, on encore en
anglais d’overloading en anglais.
– Le choix de la méthode à utiliser est en fonction des
paramètres passés à l'appel.
• Ce choix est réalisé de façon statique (c'est-à-dire à la
compilation).
– Très souvent les constructeurs sont surchargés (plusieurs
constructeurs prenant des paramètres différents et
initialisant de manières différentes les objets)

10
 Surcharge de méthodes
Class Operation {
public double addition (double nombre1, double nombre2)
{
return (nombre1 + nombre2);
}
public double addition (double nombre1, double nombre2, double nombre3 )
{
return (nombre1 + nombre2+ nombre3);
}
public int addition (int nombre1, int nombre2)
{
return (nombre1 + nombre2);
}

}
11
 Les constructeurs
L'appel de new pour créer un nouvel objet déclenche, dans l'ordre :
• L'allocation mémoire nécessaire au stockage de ce nouvel objet et
l'initialisation par défaut de ces attributs,
• L'initialisation explicite des attributs, s'il y a lieu,
• L'exécution d'un constructeur. Nom_Classe nomObjet=new constructeur();
Un constructeur est une méthode d'initialisation.
class Point
{
public class TestPoint
double x; // abscisse du point Type du Valeur par défaut
{
double y; // ordonnée du point champ
public static void main(String args[]) boolean false
// constructeur char caractère de code nul
{
Point (double dx, double dy){ entier 0
Point p1 = new Point(3.0,4.0) (byte, short,
x=dx; int, long)
y=dy; flottant 0.f ou 0.
} } (float,
} double)
Point (){ // par défaut objet null

x x=0;
P1
3.0 y=0;
4.0 y
}
}
 Le constructeur par défaut
Le constructeur est une méthode :
 de même nom que la classe,
 sans type de retour.
Java offre un constructeur par défaut, sans paramètres de
code vide, à toute classe qui ne possède pas de constructeur
 Si un constructeur est définit pour la classe alors le
constructeur par défaut est inaccessible
On peut redéfinir le constructeur par défaut

13
 Les constructeur par défaut

Point.java Définition d’un constructeur. Le

public class Point constructeur par défaut (Point())
{ n’existe plus.
double x; // abscisse du Le code suivant occasionnera une
point erreur
double y; // ordonnée du
point
// constructeur TestPoint.java
Point (double dx, double dy){ public class TestPoint
x=dx; {
y=dy; public static void main(String args[])
} {
point P2= new Point();//appel du
} //constructeur par défaut
} }
Va donner une erreur à la
14
compilation
 Surcharge de constructeur
Point.java TestPoint.java
public class Point public class TestPoint
{ {
double x; // abscisse du point public static void main(String args[])
double y; // ordonnée du point {
// plusieurs constructeurs Point p1= new Point()
Point (){ Redéfinition Point p2=new Point(3);
x=0; d’un
Point p3=new Point(3,4);
Constructeur
y=0; Point p3=new Point(3,4,5);
sans
} paramètres
Point (double dx){ }
x=dx;
y=0; }
}
Point (double dx, double dy){ Va donner une erreur à la compilation
x=dx;
y=dy;
} On définit plusieurs constructeurs
qui se différencient uniquement
} par leurs paramètres (surcharge)
15
 L’autoréférence : this

 Le mot réservé this, utilisé dans une méthode, désigne la

référence de l'instance (objet) à laquelle le message a été
envoyée (donc celle sur laquelle la méthode est « exécutée »).
public setX(double dx) {
x=dx;
}
 Il est utilisé principalement :
1. Pour lever une ambiguïté,
2. Dans un constructeur, pour appeler un autre constructeur de la même
classe.

16
 L’autoréférence : this
class Point
{
private double x;
private double y;
Point(double x,double y)
{
this.x=x; Pour lever l’ambiguïté sur les mots « x » et
this.y=y; «y»
}
}
public Point(double x, double y)
{
this.x=x;
this.y=y;
} Appelle le constructeur
point(double a, double b)
Public Point(double y)
{
this(0,y);
}

public Point() Appelle le constructeur

{ Point(double y)
this(0);
17
}
 Accès aux attributs d’un objet
Point.java
TestPoint.java Accès aux attributs x et y
De l’objet p1 public class Point
public class Application {
{ double x; // abscisse du point
public static void main(String args[]) double y; // ordonnée du point
{ // plusieurs constructeurs
Point p1 = new Point() double getX (){
p1.x = 10 ; return x
P1.y = 20 ; }
} double getY (){
} return y
}
void setX(double dx){
x=dx;
}
void setY(double dy){
y=dy;
}

}
18
 Accès aux méthodes d’un objet
Point.java
Accès au méthodes setX et setY public class Point
de l’objet p1 {
double x; // abscisse du point
TestPoint.java
double y; // ordonnée du point
public class Application // plusieurs constructeurs
{ double getX (){
public static void main(String args[]) return x
{ }
Point p1 = new Point(); double getY (){
p1.setX ( 10) ; return y
P1.setY( 20); }
} void setX(double dx){
} x=dx;
}
void setY(double dy){
y=dy;
}

}
19
 L’encapsulation
Notion d'encapsulation :
 Les données et les procédures qui les manipulent sont
regroupées dans une même entité, l'objet.
 Les détails d'implémentation sont cachés, le monde
extérieur n'ayant accès aux données que par
l'intermédiaire d'un ensemble d'opérations constituant
l'interface de l'objet.
 Le programmeur n'a pas à se soucier de la représentation
physique des entités utilisées et peut raisonner en termes
d'abstractions.
20
 Contrôle d’accès
Chaque attribut et chaque méthode d'une classe peut être :
Modificateur Rôle
public Une variable, méthode ou classe déclarée public est visible par tous les
autres objets.
par défaut : Il n'existe pas de mot clé pour définir ce niveau, qui est le niveau par
package défaut lorsqu'aucun modificateur n'est précisé. Cette déclaration permet
friendly à une entité (classe, méthode ou variable) d'être visible par toutes les
classes se trouvant dans le même package.
protected Si une méthode ou une variable est déclarée protected , seules les
méthodes présentes dans le même package que cette classe ou ses sous
classes pourront y accéder.
C'est le niveau de protection le plus fort. Les composants ne sont visibles
private qu'à l'intérieur de la classe : ils ne peuvent être modifiés que par des
méthodes définies dans la classe prévues à cet effet. Les méthodes
déclarées private ne peuvent pas être en même temps déclarée abstract
car elles ne peuvent pas être redéfinies dans les classes filles.
 Contrôle d’accès Point.java
public class Point
{
private double x; // abscisse
TestPoint.java private double y; // ordonnée
public class TestPoint // plusieurs constructeurs
{ public double getX (){
public static void main(String args[]) return x
{ }
Point p1 = new Point(); public double getY(){
p1.x = 5; // Invalide car l'attribut est privé return y
p1.setX( 4); // OK }
p1.affiche( ); // OK
} public void setX(double dx){
} x=dx;
}
public void setYdouble dy){
y=dy;
}
public void affiche()
System.out.println(“abscisse est:“+
x + ordonnée est :“+y);
}
 Contrôle d’accès

En toute rigueur, il faudrait que :

 Les attributs ne soient pas visibles,
 Les méthodes "utilitaires" ne soient pas visibles,
 Seules les fonctionnalités de l'objet, destinées à être
utilisées par d'autres objets qui sont visibles.
C’est la notion d’encapsulation

23
 Champs de classe
Il peut s'avérer nécessaire de définir un attribut dont la valeur
soit partagée par toutes les instances (objets) d'une classe. On
parle de variable de classe.
Ces champs sont stockées une seule fois.
Mot réservé : static
Accès :
 via une instance de la classe,
 à l'aide du nom de la classe.

24
 Champs de classe
Point.java
public class Point
{ private double x; private double y;
public static int compteur = 0;
public Point(double x, double y) Variable de classe
{
This.x=x; Utilisation de la variable de classe
This.y=y; compteur dans le constructeur de
// compter le nombre d’instance
compteur++; la classe
}
} Utilisation de la variable de classe
public class TestPoint compteur dans une autre classe
{
public static void main(String args[])
{ x
Int a; P1 3
4 y
Point p1 = new Point(3,4);
Point p2 = new Point(5,6); P2 5 x
a=Point.compteur; 6 y
System.out.println(“le nombre de points créés est :“+ a);
}
} 0
2
1 Compteur
25
 Méthodes de classe

Il peut être nécessaire de disposer d'une méthode qui puisse être
appelée sans l’existance d’une instance de la classe. C'est une
méthode de classe.
On utilise là aussi le mot réservé static
Puisqu'une méthode de classe peut être appelée sans même qu'il
n'existe d'instance, une méthode de classe ne peut pas accéder à
des attributs non statiques. Elle ne peut accéder qu'à ses propres
variables et à des variables de type classe.

26
 Méthodes de classe
Point.java TestPoint.java
public class Point public class TestPoint
{ {
private double x,y; Int b;
private static int compteur = 0; public static void main(String args[])
{
public Point() Int a;
{ Point p1 = new Point();
// compter le nombre d’instance Point p2 = new Point();
compteur++; a=Point.Nb_Point();
} System.out.println(“le nombre de
public static int Nb_Point() points créés est :“+ a);
{ b=a; // erreur une méthode static (main)ne
return compteur ; peut accéder à un attribut non statique
} }
} }

Méthode de classe Autres exemples de méthodes

manipulant une Math.sqrt(x); de classe courantes
variable de classe String.valueOf (i);
27
 Destruction d’objets

Java n'a pas repris à son compte la notion de destructeur telle

qu’elle existe en C++ par exemple.
C'est le ramasse-miettes (ou Garbage Collector - GC en anglais)
qui s'occupe de collecter les objets qui ne sont plus référencés.
Le ramasse-miettes fonctionne en permanence dans un thread
de faible priorité (en « tâche de fond »). Il est basé sur le
principe du compteur de références.

28
 Destruction d’objets

Il est possible au programmeur d'indiquer ce qu'il faut

faire juste avant de détruire un objet.
C'est le but de la méthode finalize()de l'objet.
Cette méthode est utile, par exemple, pour :
 fermer une base de données,
 fermer un fichier,
 couper une connexion réseau,
 etc.

29
 Destruction d’objets
Point.java TestPoint.java
class Point { public class TestPoint {
private double x,y; int b;
private static int compteur=0; public static void main(String args[]) {
public Point() int a;
{ Point p1 = new Point();
// compter le nombre d’instance Point p2 = new Point();
compteur++; a=Point.Nb_Point();
} System.out.println("le nombre de points "+a);
p2=null;
public static int Nb_Point() System.gc();// appel explicite du Garbage collector
{ Thread.sleep(1000);
return compteur ; a=Point.Nb_Point();
} System.out.println("le nombre de points "+a+" ");
protected void finalize() }
{ }
System.out.println("dans finalize"); }
compteur--;
}
}

30