Le document présente les concepts fondamentaux de la programmation orientée objet en Java, y compris la définition des classes, des attributs et des méthodes. Il traite également de l'encapsulation, des constructeurs et destructeurs, ainsi que de l'instanciation et de l'utilisation des objets. Des exercices pratiques sont inclus pour renforcer la compréhension des concepts abordés.

1. 7
CHAPITRE 2
CLASSE ET OBJET

2. 8
1. La Classe
Dans une classe sont définis des attributs et des méthodes qui seront présents dans chaque
objet créé à partir de cette classe.
Déclarer les attributs de la classe permet de décrire l’état du futur objet
Déclarer les méthodes de la classe permet au futur objet d’effectuer des opérations et
éventuellement changer d’état.
1.1. Définition d’une classe
La syntaxe la plus simple de définition d’une classe en Java est la suivante :
[private/public] class <NomClasse>
{
//déclaration des attributs
…………………………
//déclaration des méthodes
…………………………
}
Par convention, le nom de la classe commence par une majuscule suivie de minuscules
avec une majuscule pour chaque nouveau mot.
Dans un fichier Java, il ne peut y avoir qu’une seule classe publique.
Les modificateur private et public : sont deux modificateur d’accès précisant la possibilité
d’utilisation de la classe :
o private indique que l’utilisation de la classe est réservée aux classes du même
package (regroupement logique des classes).
o public donne la possibilité d’utiliser la classe à toutes les autres classes.
o Par défaut, le modificateur est private.
Exemple :
public class Rectangle {
int longueur ;
int largeur ;
int surface () {
return longueur * largeur ;
}
}

3. 9
1.2. Déclaration des attributs
En Java, la syntaxe de déclaration d’un attribut est la suivante :
[<modificateur de visibilité>] <type> <nom_attribut> [=<expression>] ;
Les attributs sont caractérisés par un nom, un type et une valeur
Le modificateur de visibilité indique l’accessibilité de l’attribut à l’extérieur de sa classe
et peut être :
o private : indique que l’accès est réservé aux méthodes de la classe elle-même,
o public : donne la possibilité d’accès à toutes les méthodes des autres classes,
o protected : limite l’accès aux méthodes de la même classe, des classes dérivés (voir
chapitre héritage) et des classes du même package.
Le type peut être élémentaire ou spécial (classe, tableau, …)
L’expression permet d’affecter une valeur lors de la création d’un objet
Les attributs sont considérés comme des variables globales à l’intérieur d’une classe : ils
sont visibles par toutes les méthodes de la classe.
Par convention, le nom d’un attribut commence par une minuscule suivie de minuscules
avec une majuscule pour chaque nouveau mot.
Exemple :
public class Rectangle {
//déclaration de deux attributs entiers d’accès public
public int longueur ;
public int largeur ;
………….
}
1.3. Déclaration des méthodes
En Java, la syntaxe de déclaration d’une méthode est la suivante :
[<modificateur de visibilité>] <type_retour> <nom_méthode> (<arguments>) {
// Déclaration des variables locales
// Instructions de la méthode
}

4. 10
Le modificateur de visibilité indique l’accessibilité autorisant ou pas l’appel aux
méthodes de la classe (voir déclaration des attributs).
Le type de retour est le type de la valeur renvoyée par la fonction, si pas de renvoi le type
est « void »
Les arguments de la méthode est une liste de paramètres formels, nommés et typés
séparés par des virgules, (cette liste peut être vide)
Les variables à l’intérieur d’une méthode sont locales à cette méthode et doivent être
initialisées avant toute utilisation.
Par convention, le nom d’une méthode commence par une minuscule suivie de minuscules
avec une majuscule pour chaque nouveau mot.
Exemple :
public class Rectangle {
public int longueur ; //attribut de la classe Rectangle
public int largeur ;
//méthode qui calcule la surface à partir de deux paramètres entiers
private int surface (int long, int larg) {
int surf ; //variable locale à la méthode
surf = long * larg ;
return surf ; //valeur de retour de la méthode
}
//méthode qui affiche les attributs de la classe sans paramètres et sans retour
public void afficher ( ) {
System.out.println ("longueur : " + longueur + "largeur : " + largeur) ;
}
}
1.4. Encapsulation
Le regroupement des données et des méthodes dans un objet ainsi que le masquage des
données est appelé encapsulation.
L’encapsulation permet d’offrir aux utilisateurs la liste des services exportables appelé
interface composée d’attributs et de méthodes « publics »

5. 11
L’encapsulation de données dans un objet permet de cacher ou non leur existence aux
autres objets du programme. Une donnée peut être déclarée en accès :
o public : les autres objets peuvent accéder à la valeur de cette donnée ainsi que la
modifier ;
o private : les autres objets n’ont pas le droit d’accéder directement à la valeur de cette
donnée (ni de la modifier). En revanche, ils peuvent le faire indirectement par des
méthodes de l’objet concerné (si celles-ci existent en accès public).
Exercice :
Ecrire une classe Rectangle qui encapsule 4 entiers : la longueur, la largeur, la position en
abscisse et en ordonnée de l’origine du rectangle. La classe Rectangle implémente une
méthode permettant de déplacer le rectangle qui nécessite en entrée deux entiers indiquant la
distance de déplacement en abscisse et en ordonnée.
1.5. Constructeur de la classe
Un constructeur est une méthode particulière appelée au moment de la création pour
initialiser l’objet en fonction des paramètres fournis par l’utilisateur.
Règles à respecter :
o Le nom du constructeur doit correspondre exactement au nom de la classe
o Aucun type de retour déclaré par le constructeur
Une classe peut avoir plusieurs constructeurs avec des listes d’arguments qui déterminent
quel constructeur doit être utilisé lors de l’appel de l’un des constructeurs.
Toute classe doit avoir au moins un constructeur.
Si aucun constructeur n’a été écrit dans la classe, un constructeur par défaut est fourni
sans arguments et son corps est vide.
Si une classe comporte au moins un constructeur, elle perd son constructeur par défaut.
Exemple :
public class Rectangle {
public int longueur ;
public int largeur ;
//Constructeur par défaut explicite
Rectangle () {

6. 12
longueur = 0;
largeur = 0 ;
}
//Constructeur avec arguments
Rectangle (int a, int b) {
longueur = a;
largeur = b ;
}
}
1.6. Notion de Destructeur
Le destructeur est une méthode qui exécute certaines tâches avant la destruction de
l’objet.
La destruction d’un objet (libération mémoire) se fait d’une manière automatique à l’aide
du mécanisme de « garbage collector » qui est un processus en exécution permanente.
En Java, le destructeur est optionnel et s’il est décrit, alors il est unique.
En Java, le destructeur s’appelle finalize. Son prototype est protected void finalize ().
Exemple :
public class Rectangle {
private static int nbRectangle = 0 ;
public int longueur ;
public int largeur ;
Rectangle (int a, int b) {
longueur = a;
largeur = b ;
nbRectangle ++ ;
}
//le destructeur est optionnel et il est utilisé que pour des tâches qui précèdent la destruction
protected void finalize () {
nbRectangle -- ; }
}

7. 13
2. L’Objet
Un objet est caractérisé par :
o Un ensemble d’attributs nommés et typés représentants ses propriétés statiques.
o Un ensemble de méthodes définissant son comportement et ses réactions face aux
stimulations externes
o Une identité qui permet de le distinguer.
2.1. Instanciation
Pour instancier (ou créer ) un objet, il faut :
1. Déclarer une variable de la classe à instancier (la variable n’est pas l’objet mais une
référence sur l’objet, elle contiendra son adresse)
2. Allouer l’espace mémoire nécessaire à l’objet en utilisant l’opérateur new et affecter
l’adresse de l’objet dans la variable référence.
A l’exécution de new, les données d’un objet sont initialisées automatiquement par des
valeurs nulles (null).
L’initialisation d’un objet peut être explicite si on met des valeurs lors de la déclaration
des attributs.
Exemple :
//Objet rectangle1 instancié à partir du constructeur par défaut
Rectangle rectangle1 = new Rectangle () ;
//Objet rectangle2 instancié partir du constructeur Rectangle (int, int)
Rectangle rectangle2 = new Rectangle (10, 5) ;
2.2. Utiliser un objet
Accès à un attribut
L’accès à un attribut d’une classe se fait toujours à l’intérieur d’une méthode.
Si la méthode (sauf pour main) appartient à la même classe que l’attribut, alors l’accès se
fait en indiquant le nom de l’attribut directement.
Si la méthode n’appartient pas à la même classe que l’attribut ou qu’il s’agit de la
méthode main, alors il faut créer d’abord un objet à partir de la classe de l’attribut et y
accéder en séparant le nom de l’objet et le nom de l’attribut par un point, comme suit :
<nom_objet>.<nom_attribut> ;

8. 14
Exemple :
public class TestRectangle {
public static void main (String [] args) {
Rectangle r1;
r1 = new Rectangle (10, 5);
//affichage des attributs de l’objet r1
System.out.println ("longueur : " + r1.longueur + "largeur : " + r1.largeur) ;
}
}
Accès à une méthode
Si’ l’appel d’une méthode est effectué à l’intérieur de la classe (dasn une autre méthode
sauf pour main), alors on écrit directement :
<nom_méthode> (<liste_paramètres>) ;
Si l’appel d’une méthode est effectué à l’extérieur de la classe (dans une méthode) ou dans
la méthode main de cette même classe, alors il faut créer un objet de cette classe et appeler
la méthode comme suit :
<nom_objet>.<nom_méthode> (<liste_paramètres>) ;
Exemple :
public class TestRectangle {
public static void main (String [] args) {
Rectangle r1 = new Rectangle (10, 5);
//affichage des attributs de l’objet r1 à travers la méthode afficher() de Rectangle
r1.afficher() ;
}
}
Exercice :
Ecrire une classe principale (contenant main) qui permet de créer deux objets de type
Rectangle et qui permute les attributs (longueur et largeur) de ces deux objets.

9. 15
2.3.Référence d’un objet
Les références sont des variables qui permettent de désigner et de manipuler les objets.
o Le mot clé « this » :
this représente une référence sur l’objet courant, c.à.d. celui qui possède la méthode
qui est en train de s’exécuter.
La référence this peut être utile :
Pour distinguer une variable locale portant le même nom qu’un attribut de la
classe.
Pour déclencher un constructeur depuis un autre constructeur.
Exemple :
public class Rectangle {
private int longueur, largeur ;
public Rectangle (int longueur, int largeur) {
this.longueur = longueur ;
this.largeur = largeur ;
}
public Rectangle () {
this (0,0) ; //appel de Rectangle (int, int)
System.out.println ("constructeur sans arguments ") ;
}
}
o Le mot clé « null » :
Le mot clé null, permet de représenter la référence qui ne désigne rien.
On peut assigner la valeur null à n’importe quelle variable ou attribut contenant une
référence.
null est la valeur par défaut d’initialisation des attributs représentant des références.
Exemple :
public static void main (String [] args) {
Rectangle r1 ; //r1 est local à main
r1.aficher() ; //erreur de compilation , r1 n’a pas encore reçu de valeur

10. 16
Rectangle r2 = null ; //r2 est local à main et initialisée à null
r2.afficher() ; //erreur d’exécution cette fois
}
o Les opérateurs sur les références :
== : pour tester si deux références désignent le même objet
!= : pour tester si deux références ne désignent pas le même objet
= : affecte une référence dans une autre
instanceOf : pour tester si l’objet référencé est une instance d’une classe donnée (ou
d’une de ses sous-classes) retourne true ou false.
Exemple :
Rectangle r1 = new Rectangle (5,3) ;
Rectangle r2 = new Rectangle (10,5) ;
r1 = r2 ;
if (r1 != r2) {
System.out.println ("r1 et r2 ne désignent pas le même objet") ;
}
if (r1 instanceOf Rectangle ) {
System.out.println ("r1 est un objet de type Rectangle") ;
}
2.4. Les objets membres
Les champs d’une classe peuvent être des références à des objets. On parle d’objets
membres.
Si l’objet jouant le rôle d’attribut est déjà créé (utilisé ailleurs), il suffit d’effectuer une
affectation entre références à travers un passage de paramètres au niveau du constructeur
ou d’une autre méthode. (1er
cas)
Si l’utilisation de l’objet membre est réservée à l’objet qui l’intègre, alors l’objet membre
doit être créé par new au niveau du constructeur de la classe qui l’utilise ou une autre
méthode. (2ème
cas)
Exemple :
public class Point { …… }
public class Rectangle{

11. 17
private Point centre ;
private int longueur, largeur ;
public Rectangle (int L, int l, Point p) {
longueur = L ; largeur = l ; centre = p ; // 1er
cas
}
public Rectangle () {
longueur = 10 ; largeur = 5 ; centre = new Point (0,0) ; // 2ème
cas
}
}
3. Exercices
Exercice N°1 :
1. Ecrire une classe Point caractérisée par :
- Deux attributs privés : son abscisse et son ordonnée,
- un constructeur avec arguments,
- un constructeur sans arguments, qui initialise les coordonnées d’un point par des
valeurs par défauts de votre choix,
- Une méthode pour afficher les coordonnées d’un point sous la forme p=(x, y).
- Une méthode pour déplacer le point en ajoutant les valeurs en arguments de cette
méthode aux valeurs des coordonnées du point.
2. Ecrire une méthode main qui permet d’initialiser et d’afficher un point, puis de le déplacer
et de le réafficher.
Exercice N°2 :
On se propose de décrire deux figures centrées : le cercle et le rectangle. Chacune est
caractérisée par un centre décrit par ses coordonnées. De plus, un cercle est caractérisé par son
rayon alors qu’un rectangle par sa longueur et sa largeur.
1. Donner la spécification des classes de chaque objet (point, cercle et rectangle) avec
des attributs publics.
2. Ajouter pour chacune des classes Cercle et Rectangle une méthode afficher () qui
permet d’afficher leurs attributs.
3. Ecrire une classe principale qui permet de tester le programme
4. Modifier les attributs de la classe Point en privés. Que se passe-t-il à l’exécution ?
5. Ajouter une méthode publique afficher() à la classe Point.
6. Modifier les méthodes d’affichage de Cercle et Rectangle pour pouvoir les afficher
tout en maintenant les coordonnées des points privés.
Exercice N°3 :
Une personne est caractérisée par un CIN, un nom, un prénom et une adresse. L’adresse peut
être composée des éléments suivants : numéro, nom de la rue, ville et code postal.
1. Définir la classe Adresse
2. Définir la classe Personne en utilisant un objet Adresse.

12. 18
3. La classe TestProgramme permet de créer deux objets de type personne. Ali habite 36
rue des oliviers, 3002 Sfax et Mohamed habite 20 rue de la liberté, 1002 Tunis.
4. Ecrire une méthode Afficher qui permet d’afficher une personne et une méthode
Permuter qui permet de permuter les adresses de deux personnes selon les cas
suivants :
4.1. Afficher et Permuter sont deux méthodes de la classe Personne
4.2.Afficher et Permuter sont deux méthodes de la classe TestProgramme
Exercice N°4 :
1. Ecrire la classe Nombre qui permet de définir un nombre par sa valeur numérique de
type entier. La classe contient les méthodes suivantes :
- Le constructeur de Nombre permet de l’initialiser par une certaine valeur,
- Méthode d’incrémentation de sa valeur par 1,
- Méthode de décrémentation de sa valeur par 1,
- Méthode d’affichage de sa valeur.
2. Ecrire la classe TestNombre qui dans sa méthode main doit créer un nombre,
l’incrémenter de 2 puis de le décrémenter de 1. Utiliser la méthode d’affichage pour
vérifier la valeur du nombre à chaque fois.
3. Que se passera-t-il si on procède à déclarer l’attribut de la classe Nombre comme étant
final.
4. On veut ajouter l’instruction suivante Nombre n = new Nombre() ; dans main.
4.1.Qu’appelle-t-on ce constructeur utilisé ?
4.2.Cette instruction provoquerait-elle une erreur et pourquoi ?
4.3.Comment pourrait-on alors l’utiliser sans générer une erreur ?
Exercice N°5 :
1. Créer une classe Temps qui contient 3 attributs entiers privés : heure, minute, seconde
Définir les constructeurs suivants en utilisant chaque fois que c’est possible la
référence this.
- Temps (int heure)
- Temps (int heure, int minute)
- Temps (int heure, int minute, int seconde)
2. Ecrire une méthode affiche() qui affiche le temps sous la forme suivante :
"Il est ……..heures ……..minutes……..secondes"
3. Ecrire la méthode main qui permet d’utiliser les trois types de constructeur suivis de la
méthode affiche() et qu’obtient-on à l’exécution ?