Chapitre 3: Utilisation des

Classes et Objets
2025/2026

M. BEROUINE

CHAP3 –UTILISATION DES CLASSES ET OBJETS

Plan

 Notion d’objet et de classe

 Déclaration d’une classe en Java
 Les attributs d’une classe
 Création des objets
 Visibilité et accès aux membres d'une classe.
 Exécuter une application java.
 Les variables et constante de classe
 méthodes d’instance et de classe.
 Surcharge des méthodes

CHAP3 –UTILISATION DES CLASSES ET OBJETS 1

La classe (Rappel)
 Une classe est un type de données abstrait.

 Les classes réunissent les caractéristiques communes à un ensemble d'objets.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 2

Objet (Rappel)
 En Java tout est objet.
 Un objet réel est l'autre nom d'une instance de classe.
 Si les classes sont une représentation abstraite d'un objet, une instance en est une représentation
concrète

CHAP3 –UTILISATION DES CLASSES ET OBJETS 3

Les membres d’une classe Java
• Des attributs (ou champs) :
• Des variables d’instance/de classe.
• Des constantes.

• Des méthodes:
• Des constructeurs: qui permettent de créer des objets.
• Des getters et setters: qui permettent d’accéder et de modifier les attributs.
• Des méthodes: les opérations que l’on peut effectuer.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 4

Conventions d’écriture
• Toute méthode, attribut et variable d’instance commence par une minuscule.
• Exemple: nom, compte, compteBancaire, distance(), calculDistance().

• Tout changement de mot descriptif se fait via une majuscule.

• Exemple: getString(); ajouterUnNouveauEtudiant(), calculSurfaceDuCerle().

• Tout nom de classe commence par une majuscule. Tout changement de mot descriptif se fait via
une majuscule.
• Exemple: Etudiant; Cercle, FormeGeometrique, CompteClient.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 5

Déclaration d’une classe en java
• La définition d’une classe correspond à :
• Exemple:
En java:

En UML:

CHAP3 –UTILISATION DES CLASSES ET OBJETS 6

Les attributs (Définition)
• Les attributs sont les caractéristiques individuelles qui différencient un objet d'un autre. Il
définissent l'état d'un objet.

• Soit une classe appelée Motor-cycle avec les attributs suivants:

• Couleur
• style
• puissance
• marque

CHAP3 –UTILISATION DES CLASSES ET OBJETS 7

Les attributs d’une classe (attributs d’instance)
• Les variables d’instance ou attributs d’instance:

• Les constantes:

• Les variables et constantes de classe ou bien statiques:

• A voir par la suite
• Les attributs possèdent une valeur par défaut qui leur est affectée lors de la création d’un objet:
• 0 pour les types numériques primitifs
• false pour les booléens
• null pour les types référence d’objets
• Tandis que les variables locales doivent nécessairement être initialisées avant d’être utilisées.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 8

Visibilité des attributs d’une classe
• La visibilité des attributs peut être modifiée selon la décision du développeur.
• La possibilité d’accéder, directement, aux attributs d’une classe Java, n’est pas recommandé car on
ne respecte pas le principe de l’encapsulation.
• Les données (attributs) doivent être, le plus possible, masquées et inaccessibles par l’extérieur.
• L’accès aux données masquées se fait, seulement, par les méthodes bien spécifiées (getters/setters).

• On distingue trois niveaux de visibilité (droits d’accès):

• Le niveau public (public): l’accès aux données peut être fait par les méthodes Public
Toutes les classes
de toutes les autres classes. Niveau de protection le plus bas.
protected
• Le niveau privé (private): les attributs sont masquées à l’intérieur d’un Les sous-classes

Objet et l’accès à ces données est limité aux méthodes (getters/setters).

private
Niveau de protection le plus élevé. La classe

• Le niveau protégé (protected): ): l’accès aux données est réservé aux méthodes
des classes dérivées. (A revoir dans le chapitre abordant la notion d’héritage).

CHAP3 –UTILISATION DES CLASSES ET OBJETS 9

Création des objets: Instanciation
• L'instanciation se fait pour initialiser un objet:

• Provoque la création réelle de l'objet en mémoire par l'initialisation de ses attributs.

• Chaque objet crée, possédera donc ses propres valeurs d'attributs, distinctes des valeurs d'attributs
d'un autre objet.

• L'instanciation se fait par l' emploi du mot clé new.

Point pl;
• L'instruction suivante: Point pl = new Point(); ou bien,
pl= new Point();
• Definit un objet p1 de type Point par le constructeur Point().

• Exemple: Scanner sc = new Scanner (System. in) ;

Constructeur ??????

CHAP3 –UTILISATION DES CLASSES ET OBJETS 10

Constructeurs d’objets
• Les constructeurs sont des méthodes particulières qui permettent de fabriquer (créer) Les objets,
en effectuant certaines initialisations nécessaires pour le nouvel objet cree.

• Le constructeur porte le même nom que la classe a laquelle il appartient,

• Un constructeur n'est précède ni par le mot clé void ni par le type de retour,
• On peut définir autant de constructeurs qu'on souhaite,
• Les autres constructeurs peuvent comporter de 1 à n arguments (Surcharge),

• Toute classe Java possède au moins un constructeur.

• Si une classe ne définit pas explicitement de constructeur, un constructeur par défaut, sans
arguments et qui n'effectue aucune initialisation particulière, est invoque (de la classe Object).

CHAP3 –UTILISATION DES CLASSES ET OBJETS 11

Constructeurs d’objets – Exemple
public class Point{
• Utilisation:
// Attributs
public int abscisse;
Point pl= new Point();
public int ordonnee;
Point p2 = new Point(3,4);
// Constructeurs
public Point(){
abscisse=O;
Constructeur • Representation:
ordonnee=O;
par defaut
}
:pl :p2
public Point(int x, int y){
abscisse : 0 abscisse : 3
abscisse=x;
ordonnee: 0 ordonnee: 4
ordonnee=y; Constructeur
} avec arguments
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 12

 Constructeurs d’objets – Exemple 2
public class Etudiant{
• Utilisation:
// Attributs
public int id;
public String nom;
public float moyenne;
// Constructeurs
public Etudiant(){
} • Représentation:
public Etudiant(int x, String y, float z){
: e1 : e2
id=x;
id : 1
Nom=y; null
Nom : Durant
moyenne=z;
Moyenne : 15,2
}
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 13

 Constructeurs d’objets - Référence d’objet
public class Point{ Il n’y désormais plus de référence
public int abscisse; vers l’ancien point(0,0), il sera
donc détruit par le Garbage
public int ordonnee; collector (ramasse-miettes)

// Utlisation :
public class Test{ p1
0 abscisse
public static void main(String[] args){ 36baf0C
0 ordonnee
Point pl= new Point(); 17a81197d
Point p2 = new Point(3,4);
point p=p2;
[Link]=12;
p2 3 12 abscisse
p1=p;
17a81197d 4 ordonnee
}
} 17a81197d
p
CHAP3 –UTILISATION DES CLASSES ET OBJETS 14
 L’accès aux membres d’une classe
• A l'intérieur d'une meme classe, pour accéder à un attribut public class Point {

ou bien pour faire appel à une méthode, on utilise, tout public int abscisse;
private int ordonnee;
simplement, leurs identificateurs (leurs noms).
public double distance(int x, int y){}
• On peut, aussi, utiliser la notation pointée: private void f(){
[Link]. ordonnee = 10; [Link] = 10;
d o u b l e d = distance(5,3);}
• En revanche, l'acces aux attributs publics d'une classe dans
}
d'autres classes, se fait par la notation pointee: public class Droite{
• p.a ou p designe l'objet et a le nom de l'attribut int a,b; // publics dans le package
(idem pour Les méthodes). public void m() {
Point pl= new Point();

• Les attributs privés et les méthodes privées d'une classe ne a= [Link]; //OK

sont pas accessibles, directement, dans d'autres classes. b = [Link]; //Faux

double d= [Link](5,3); //OK
Alors, comment acceder aux attributs prives d'un objet a pl.f(); //Faux
partir d'un autre ??? }}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 16

 Méthodes d'accès aux attributs privés (getters et setters)
• Les méthodes d'accès aux attributs sont des opérations que l'on peut effectuer sur les attributs d'une
classe. On distingue deux types de méthodes:
• Les accesseurs:
• Les accesseurs sont les méthodes utilisées pour la récupération de la valeur d’un attribut privé (Accès en
lecture).
• Les accesseurs sont des méthodes d’instances, qui commencent par get, On les appelle aussi les getters.
• Exemple: getAbscisse(), getOrdonnee(), getMoyenne().

• Les modificateurs:
• Les modificateurs ou bien les setters sont les méthodes utilisées pour assigner une valeur à un
attribut privé (Accès en écriture),
• Les modificateurs sont des méthodes d’instances, commencent par set, On les appelle aussi les setters.
• Exemple: setAbscisse(), setOrdonnee(), setMoyenne().

CHAP3 –UTILISATION DES CLASSES ET OBJETS 17

 Exemple de getters et setters - class Point
public int getAbscisse() {
public class Point{
return abscisse;
private int abscisse;
}
private int ordonnee;
public void setAbscisse(int x) {
//Constructeurs abscisse = x;
public Point(){ }
abscisse=0; //-----------------------------------
ordonnee=0; public int getOrdonnee() {
} return ordonnee;
}
public Point(int x, int y){ public void setOrdonnee(int y) {
abscisse=x; ordonnee = y;
ordonnee=y; }
} public void setPoint(int x, int y) {
abscisse x;
}
ordonnee = y;
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 18

 Exemple de getters et setters - class Etudiant
public class Etudiant{ public String getNom() {
return nom;
// Attributs
}
public String nom;
public void setNom(String y) { nom =
public float moyenne;
y;
}
// Constructeurs //-----------------------------------
public Etudiant(){ public float getMoyenne() {
}
return moyenne;
}
public Etudiant(String y, float z){
public void setMoyenne(float z)
Nom=y; {moyenne = y;
moyenne=z; }

} public void setEtudiant(String y, float z) {

nom= y;
} moyenne=z;
}
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 19

Le mot clé this (Auto-référencement)
• Les méthodes setAbscisse, setOrdonnee et setPoint, utilisent des paramètres qui portent des
noms differents de ceux des attributs pour eviter la confusion. (setAbscisse(int x), etc.)
• Il est possible de les appeler également abscisse et ordonnee.
• La distinction est faite en utilisant la réference this.
• [Link] designe l'attribut de l'objet courant (this).

CHAP3 –UTILISATION DES CLASSES ET OBJETS 20

Les méthode de base toString()
• ToString est une méthode utilisée pour afficher les avaleurs assignés aux attributs d’un objet.
• Exemple: Dans la classe Point et Etudiant on redéfini la methode toString comme suit:

public String toString() {

Return "(" + abscisse + "," + ordonnee + ")" ; } //(3,4)

public String toString() {

Return "Etudiant [id="+ id+ ", nom="+ nom+ ", moyenne="+ moyenne+ "]";

• Cette méthode est appelé par défaut si on affiche l’objet de recrutement sur la console en
utilisant l’instruction System out println (objet).
Point pl=new Point(3,4); ===
[Link](" Les coordonnees du point pl sont:"+ pl);

Etudiant el=new Etudiant(1,"durant",15.2);

[Link](el); ====

CHAP3 –UTILISATION DES CLASSES ET OBJETS 21

Exécuter une application java
• Une application Java peut etre vue comme une conversation entre objets.

• L'initiatrice de cette conversation est habituellement une classe qui possede dans sa
définition une méthode appelée main().

• La méthode main est l'endroit ou on commence l‘éxecution.

• C'est à partir de cette méthode qu'un programme java demarre automatiquement.

• C'est préférable, dans une application java, de définir la méthode main dans une autre
classe à part, que dans l'une des classes constituant l'application.

public class Application{ //On peut choisir un nom quelconque

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

CHAP3 –UTILISATION DES CLASSES ET OBJETS 22

Exercice d’application
 Combien d’instances de la classe A, crée le code suivant ?
A x ,u ,v;
x = new A(); Solution:
A y = x;
A z = new A(); x = new A(); x

A u =x; x

A v = new A(); x

CHAP3 –UTILISATION DES CLASSES ET OBJETS 23

 Exemple d’application – Créer la classe Point
public int getAbscisse() {
public class Point{
return abscisse;
public int abscisse;
}
private int ordonnee;
public void setAbscisse(int x) {
//Constructeurs abscisse = x;
public Point(){ }
abscisse=0; //-----------------------------------
ordonnee=0; public int getOrdonnee() {
} return ordonnee;
}
public Point(int x, int y){ public void setOrdonnee(int y) {
abscisse=x; ordonnee = y;
ordonnee=y; }
} public void setPoint(int x, int y) {
abscisse x;
}
ordonnee = y;
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 24

 Exemple d’application – Tester la classe Point
public class Application{
public static void main(String[] args){
Point pl= new Point();
Point p2= new Point(2,3);
[Link]("l) Pl: x=" + [Link]() + y="+[Link]());
[Link]("2) P2: x=" + [Link]() + y="+p2.get0rdonnee());

[Link](12, 43);
[Link]("3) Pl: x=" + [Link]() + y="+[Link]());

[Link](20);
[Link]("4) P2: x=" + [Link]() + y="+p2.get0rdonnee());

pl=p2;
[Link]("5) Pl: x=" + [Link]() + y="+[Link]());
[Link]("6) P2: x=" + [Link]() + y="+p2.get0rdonnee());
} }

CHAP3 –UTILISATION DES CLASSES ET OBJETS 25

Les attributs d’une classe (variables de classe)
• Une variable de classe est une variable dont la valeur est partagée par toutes les instances d’une
classe ( variable/attribut statique).

• On déclare une variable de classe par le mot clé static :

CHAP3 –UTILISATION DES CLASSES ET OBJETS 26

Les attributs d’une classe (variables de classe): Exemple

20231 20232 20233 20234

Omar Ali Youssef Ahmed

Student student1 = new Student (20231, “Omar”, “EMSI”);

Student student2 = new Student (20232, “Ahmad”, “EMSI”);
Student student3 = new Student (20233, “Ali”, “EMSI”);
Student student4 = new Student (20234, “Youssef”, “EMSI”);

CHAP3 –UTILISATION DES CLASSES ET OBJETS 27

 Accès aux variables de classe
• L’accès aux variables de classe passe directement par la classe comme suite:
[Link]
Exemple :

public static void main(String[] args )

{
// acces aux attributs d’instance: Etudiant el=new Etudiant(1,"durant",15.2);
[Link](" Le nom de e1:" + [Link]);

// acces aux attributs de classe

[Link](" Le nombre max des etds IAII:"+ [Link]);

Résultat : Le nom de e1:Durant

Le nombre max des etds IAII:38

CHAP3 –UTILISATION DES CLASSES ET OBJETS 28

 Les variables de classe
• Exemple 1: Une association de plusieurs personnes (classe Personne):
• Chaque objet Personne possede un attribut nom. p1 p2 p3
• Toutes les personnes partagent un compte partage (cp). A B C
• Problèmatique: 4500 4500 4500

• Si, par exemple, la personne p2 verse 500 DH dans le compte cp:

• [Link] += 500;
• Alors, les autres personnes doivent, à leur tour, modifier la valeur de l'attribut cp: Compte
• [Link] += 500; bancaire
• [Link] += 500;
• On dit que l'attribut cp depend de tous les objets à la fois.
• Par contre l'attribut nom depend de chaque objet, on parle d'une variable d'instance.
• Solution:
p1 p2 p3
• L'attribut cp doit dependre de la classe et pas de chaque objet.
A B C
• L'attribut cp doit etre considere comme une variable de classe.
CHAP3 –UTILISATION DES CLASSES ET OBJETS 29
 Les variables de classe
• Exemple 2: Une collection de films (classe Film):

• Chaque objet Film a deux variables d'instance : f1 f2 f3

titre1 titre2 titre3
titre e t numero.
1 2 3
• Problèmatique:
• Comment peut-on connaitre le numéro à affecter à un nouveau objet Film crée ? 3

• Autrement, comment peut-on connaitre le numero du dernier objet Film cree?

• Solution: Compteur

• On ajoute un autre attribut, compteur, qui contiendra le numéro du dernier objet Film.
• L'attribut compteur sera un champs partage par tous les objets de la classe Film.
• L'attribut compteur depend de la classe et pas de chaque objet.
• L'attribut compteur est considere comme une variable de classe.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 30

 Accès aux variables de classe : Exemple 2
• La variable est définie comme des attributs, mais avec le mot-clé static:
public static int numeroFilmCourant;

• Pour y acceder, on utilise le nom de la classe Film:

[Link];
public static void main(String[] args) {
• Exemple: Film f1 = new Film("Film l");
Variable de classe
[Link] = ++[Link];
public class Film { Film f2 = new Film("Film 2");
public static int numeroFilmCourant = O;
[Link] = ++[Link];
public int numero; variables d'instances
private String titre; [Link]("Numero fl: "+[Link]);
[Link]("Numero f2: "+[Link]);
public Film(String titre){ }

[Link] - titre; }
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 31

 Les variables de classe
• L’utilité de définir, pour une classe, des attributs qui ne dependent des instances (objets):
nomEcole (college), nbrEtdInfo, nombre de films crees (compteur), compte partage (cp).

• Ces attributs s'appellent variables de classes ou variables statiques.

• Les Variables de classe sont comparables aux variables global es (ex. langage C).

• Caracteristiques d'une variable de classe:

• Elle est commune à toutes les instances d'une classe.
• C'est une variable dont il n'existe qu'un seul exemplaire associé à sa classe de définition.
• Elle existe independamment du nombre d'instances de la classe qui ont été crées,
• Elle est utilisable meme si aucune instance de la classe n'existe.
• Elle est place dans un espace mémoire commun à tous les objets de la classe.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 32

 Les constantes de classe
• Ce sont des constantes liées à une classe.
• Elles sont écrites en MAJUSCULES.
• Elles sont définies (en plus) avec Les mots clés final et static :
public static final float NOMBRE_PI = 3.1416F;
private static final double VALEUR_TVA = 0.2;

• Pour y accéder, on utilise le nom de la classe :

Cercle cl= new Cercle(5);

float surface= [Link](cl.r,2) * [Link] PI;

CHAP3 –UTILISATION DES CLASSES ET OBJETS 33

Les méthodes d’instance

• Les méthodes d’instance en JAVA décrivent le comportement d’un objet, les tâches
qu’il peut assurer.

• La déclaration d’une méthode d’instance comporte 4 parties:

1. Le nom de la méthode
2. La liste des paramètres
3. Le type d’objet ou primitif retourné par la méthode
4. Le corps de la méthode

CHAP3 –UTILISATION DES CLASSES ET OBJETS 34

Les méthodes d’instance
• Exemple d’une méthode de calcul du salaire d’un employé :

CHAP3 –UTILISATION DES CLASSES ET OBJETS 35

Les méthodes d’instance
• On utilise le mot clé void pour spécifier qu’une méthode ne retourne aucun résultats.

• L’appel d’une méthode d’instance se fait de la manière suivante:

[Link]éthodeInstance();

public static void main(String[] args) {

Etudiant etd1= new Etudiant();
[Link]();
}
CHAP3 –UTILISATION DES CLASSES ET OBJETS 36
Les méthodes de classe
• La déclaration d’une méthode de classe est faite par l’utilisation du mot clé static :

• L’appel d’une méthode d’instance se fait de la manière suivante:

[Link]éthodeClasse();

public static void main(String[] args) {

[Link]();
}

CHAP3 –UTILISATION DES CLASSES ET OBJETS 37

Les méthodes de classe
• Les méthodes de classe sont associées directement à une classe.
• Elles modifient Les variables de classe. Public class Film {

public static int getNumFilmCourant(){

• Elles sont définies avec le mot clé static: return numeroFilmCourant;
}
public static void main(String[] args) {
int num = [Link]();
}
}

• Une méthode statique ne peut pas utiliser des variables d'instance (non statiques).
• Une méthode statique ne peut pas utiliser (appeler) des méthodes non statiques.
• Elles ne peuvent non plus faire réference a une instance. (La réference this ne peut pas etre employée dans
la méthode statique)

CHAP3 –UTILISATION DES CLASSES ET OBJETS 38

 Les variables et méthodes de classe (Exercice)
• Quelles erreurs ont ete commises dans le code suivant ?
class A { public class TestA {
static private final int p = 20 ; public static void main (String args[]){
private int q ; . A a = new A();
static int f (int n){ int n = 5 ;
q = n; a.g(n);
}
a.f(n) ;
void g(int n){ f(n) ;
q = n; }
p = n; }
}
}

• Erreur 1 : La méthode statique f de A ne peut pas agir sur un champ non statique.
• Erreur 2 : l'affectation p = nest incorrecte c ar p est une constante.
• Erreur 3 : ll est preferable d'écrire A.f(n) au lieu de a. f(n).
• Erreur 4: L'appel f(n) est incorrect puisqu'il n'existe pas de methode f dans la classe Test A.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 39

La surcharge des méthodes
• Des fois on trouve des méthodes qui portent le même nom et non la même signature : un nombre
différent d’arguments ou un type différent d’arguments.
Exemple : methode(int a), methode(float x, int a), methode(String s, int a, float x)…

• C’est ce qu’on appelle la surcharge de méthodes.

• Avantages :
• Éliminer la définition de plusieurs méthodes qui font la même chose
• Permettre de définir des méthodes qui agissent différemment selon les arguments reçus.

Attention !!! Le type de retour doit rester le même, une tentation de le changer
génère une erreur de compilation.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 40

La surcharge des méthodes
• On peut définir la même méthode avec plusieurs signatures

CHAP3 –UTILISATION DES CLASSES ET OBJETS 41

 Exemple d’application
 Nous souhaitons définir une classe ResultatModule qui mémorise les notes obtenues dans un
module. Ses attributs sont l'identifiant du module, une note de CC, une note de TP et une note
d'examen. Tous les attributs sont déclarés privés.

1. Définir les attributs de cette classe, un constructeur ResultatModule (par défault et avec
paramètres), les méthodes qui permettent d'accéder aux attributs, getId, getCC, getTP, getEx,
les méthodes qui permettent de modifier les attributs, setId, setCC, setTP, setEx.
2. Adapter votre code pour une génération automatique de l’identifiant de module (auto-
incrémenté).
3. Définir une méthode calculeMoyenne qui calcule la moyenne au module et une méthode
valideModule qui renvoie true si la moyenne est supérieure ou égale à 10. Pour simplifier on
suppose que les coefficients sont respectivement 0.3, 0.2 et 0.5 quel que soit le module.

4. Créer une classe Test, qui contient la méthode main(),

pour tester La classe ci-dessus. La figure suivante montre
un exemple de test :

CHAP3 –UTILISATION DES CLASSES ET OBJETS 42

Exemple d’application (solution)

Référence au TD/TP N°4

CHAP3 –UTILISATION DES CLASSES ET OBJETS 43

TD/TP4
• Après avoir créé et utilisé la méthode principale, définie comme public static void main(String[] args, pour le
développement et l'exécution des programmes demandés (référence au TD/TP N°3), ce TP vise à proposer
des exercices pratiques pour consolider les concepts suivants :

• Création de classes utilitaires : en s'appuyant sur les exemples d'application du Chapitre 3.

• Maîtrise des instructions de base pour manipuler les classes et les objets, notamment :
• Les variables/méthodes d'instance, Les variables/méthodes de classe,
• La gestion de la visibilité des membres d'une classe.
• Utilisation des principales méthodes en Java, telles que :
• Les constructeurs : pour instancier des objets,
• Les accesseurs : pour récupérer les valeurs des attributs privés,
• Les modificateurs : pour modifier les valeurs des attributs privés,
• La méthode toString() : pour afficher l’état d’un objet.
• Combinaison des différentes instructions pour résoudre un problème.

CHAP3 –UTILISATION DES CLASSES ET OBJETS 66 66