OBJETS & CLASSES

Objets et classes

Objectifs des LOO:

 Ils manipulent des objets

 Les programmes sont découpés suivant les types des

objets manipulés
 Les données sont regroupées avec les traitements
qui les utilisent
 Une classe Facture regroupe, par exemple, tout ce

que l’on peut faire avec une facture, avec toutes les
données nécessaires à ces traitements
Qu’est-ce qu’un objet?

 Toute entité identifiable, concrète ou abstraite, peut

être considérée comme un objet
 Un objet réagit à certains messages qu'on lui envoie
de l'extérieur ; la façon dont il réagit détermine le
comportement de l'objet
 Il ne réagit pas toujours de la même façon à un
même événement ; sa réaction dépend de l’état
dans lequel il se trouve
Notion d’objet en Java
 Un objet a:
– une adresse en mémoire (identifie l’objet)
– un comportement (ou interface)
– un état interne
 L’état interne est donné par des valeurs de variables
d’instances
 Le comportement est donné par des fonctions

ou procédures, appelées méthodes

Exemple d’objet
Interactions entre objets

 Les objets interagissent en s’envoyant des messages synchrones

 Les méthodes d’un objet correspondent aux messages qu’on
peut lui envoyer : quand un objet reçoit un message, il exécute
la méthode correspondante
 Exemples : Objet qui reçoit le
message
objet1.decrisToi();
employe.setSalaire(20000);
voiture.demarre();
voiture.vaAVitesse(50); Message envoyé
Paradigme objet

La programmation objet est un paradigme, une

manière de « modéliser le monde » :
– des objets ayant un état interne et un comportement
– collaborent en s'échangeant des messages (pour
fournir les fonctionnalités que l'on demande à
l'application)

D’autres paradigmes :
– programmation impérative (Pascal, C)
– programmation fonctionnelle (Scheme, Lisp)
Classes Java

 Les objets qui collaborent dans une application

sont souvent très nombreux
 Mais on peut le plus souvent dégager des types

d'objets : des objets ont une structure et un

comportement très proches, sinon identiques
 Par exemple, tous les livres dans une application de
gestion d'une bibliothèque
 La notion de classe correspond à cette notion

de types d'objets
 Un objet correspond à une instanciation de classes
Exemple classe etudiant
Etudiant

String nom
String prénom
int numéro
void Changer_nom(string)
void Changer_numero(string)
…
Public class Etudiant {
private string nom, prenom;
private int numero;
// constructeur
public Etudiant(String unnom, String unprenom, int unnumero) {
nom = unnom;
prenom = unprenom;
numero = unnumero;
}
// méthodes
public string getnom() {
return nom; // accesseur
}

public void changernumero(int unnum) {

numero = unnum; // modificateur
}
}
Eléments d’une classe
 Les constructeurs (il peut y en avoir plusieurs) servent
à créer des objets appelés instances de la classe
 Quand une instance est créée, son état est conservé
dans les variables d’instance
 Les méthodes déterminent le comportement des
instances de la classe quand elles reçoivent un
message
 Les variables et les méthodes s’appellent les membres
de la classe
Rôles d’une classe

 Une classe est

– un type qui décrit une structure (variables d'état)
et un comportement (méthodes)
– un module pour décomposer une application en
entités plus petites
– un générateur d’objets (par ses constructeurs)
 Une classe permet d'encapsuler les objets : les
membres public sont vus de l'extérieur mais les
membres private sont cachés
Conventions pour les identificateurs

 Les noms de classes commencent par une majuscule

(ce sont les seuls avec les constantes) : Cercle,
Object
 Les mots contenus dans un identificateur commencent
par une majuscule : uneClasse, uneMethode,
uneAutreVariable
 Les constantes sont en majuscules et les mots sont
séparés par le caractère souligné « _ » :
UNE_CONSTANTE
 Si possible, des noms pour les classes et des verbes
pour les méthodes
Exercices

 Compléter l’exercice précédent sur les étudiants en y

ajoutant la possibilité de changer de nom et de
prénom d’un étudiant
 Créer une classe Point et une classe Rectangle avec
une méthode qui calcule la surface d’un rectangle.
Tester l’utilisation. Les rectangles sont définis par le
point inférieur gauche et supérieur droit
Constructeurs

Classes et instances

Une instance d’une classe est créée par un des

constructeurs de la classe
Une fois qu’elle est créée, l’instance:
– a son propre état interne (les valeurs des
variables)
– partage le code qui détermine son
comportement (les méthodes) avec les autres
instances de la classe
Constructeurs d’une classe

Chaque classe a un ou plusieurs constructeurs

qui servent à:
– créer les instances
– initialiser l’état de ces instances
Un constructeur
– a le même nom que la classe
– n’a pas de type retour
Création d’une instance
public class Employe {
private String nom, prenom;
private double salaire; variables
// Constructeur
d’instance
public Employe(String n, String p) {
nom = n;
prenom = p;
}
public void setSalaire(double s){
salaire=s;
}
...
public static void main(String[] args) {
Employe e1; création d'une instance
e1 = new Employe("Alami", "Kamal"); de Employe
e1.setSalaire(12000);
...
}
}
Plusieurs constructeurs (surcharge)
public class Employe {
private String nom, prenom;
private double salaire;
// 2 Constructeurs
public Employe(String n, String p) {
nom = n;
prenom = p;
}
public Employe(String n, String p, double s) {
nom = n;
prenom = p;
salaire = s;
}
...
e1 = new Employe("Amrani", "Karim");
e2 = new Employe("Salim", "Mohamed", 15000);
Désigner un constructeur par this()
public class Employe {
private String nom, prenom;
private double salaire;
// Ce constructeur appelle l'autre constructeur
public Employe(String n, String p) {
this(n, p, 0);
}
public Employe(String n, String p, double s) {
nom = n;
prenom = p;
salaire = s;
}
...
e1 = new Employe("Amrani", "Karim");
e2 = new Employe("Salim", "Mohamed", 15000);
Constructeur par défaut
Lorsque le code d’une classe ne comporte pas de
constructeur, un constructeur sera automatiquement
ajouté par Java

Pour une classe Classe, ce constructeur sera par

défaut défini par Java
[public] Classe() { }

Même accessibilité que

la classe (public ou non)
Méthodes
Deux types de méthodes servent à donner accès aux
variables depuis l’extérieur de la classe :
 les accesseurs en lecture pour lire les valeurs
des variables ; « accesseur en lecture » est
souvent abrégé en « accesseur »
 les accesseurs en écriture, ou modificateurs

pour modifier leur valeur

Paramètres d’une méthode
 Souvent les méthodes ou les constructeurs ont
besoin qu’on leur passe des données initiales sous
la forme de paramètres
 On doit indiquer le type des paramètres dans la

déclaration de la méthode :
setSalaire(double unSalaire)
calculerSalaire(int indice, double prime)
Quand la méthode ou le constructeur n’a pas de
paramètre, on ne met rien entre les parenthèses :
getSalaire()
Type retour d’une méthode
Quand la méthode renvoie une valeur, on doit
indiquer le type de la valeur renvoyée dans la
déclaration de la méthode :
double calculSalaire(int indice, double prime)
Le pseudo-type void indique qu’aucune valeur
n’est renvoyée :
void setSalaire(double unSalaire)
Exemples de méthodes

public class Employe {

Modificateur
private double salaire;
...
public void setSalaire(double unSalaire) {
if (unSalaire >= 0.0)
salaire = unSalaire;
}
public double getSalaire() {
return salaire;
} Accesseur
…
}
Surcharge d’une méthode
 En Java, on peut surcharger une méthode, c’est-à-
dire, ajouter une méthode qui a le même nom mais
pas la même signature qu’une autre méthode :
calculerSalaire(int)
calculerSalaire(int, double)
indice dans prime accordées
la grille des aux commerciaux
salaires
 En Java, il est interdit de surcharger une
méthode en changeant le type de retour
 Autrement dit, on ne peut différencier 2

méthodes par leur type retour

 Par exemple, il est interdit d'avoir ces 2 méthodes
dans une classe :
int calculerSalaire(int)
double calculerSalaire(int)
Types de variables

Les variables d’instances

– sont déclarées en dehors de toute méthode
– conservent l’état d’un objet, instance de la classe
– sont accessibles et partagées par toutes les méthodes
de la classe

Les variables locales

– sont déclarées à l’intérieur d’une méthode
– conservent une valeur utilisée pendant l’exécution de
la méthode
– ne sont accessibles que dans le bloc dans lequel elles
ont été déclarées
Variable locale ou variable d’instance ?
Il arrive d’hésiter entre référencer un objet
– par une variable locale d’une méthode
– ou par une variable d’instance de la classe

Si l’objet est utilisé par plusieurs méthodes de

la classe, l’objet devra être référencé par une
variable d’instance
Déclaration des variables

 Toute variable doit être déclarée avant d’être utilisée

 Déclaration d’une variable : on indique au compilateur que le
programme va utiliser une variable de ce nom et de ce type
Exemple:
double prime;
Employe e1;
Point centre;
Affectation

 L’affectation d’une valeur à une variable est

effectuée par l’instruction:
variable = expression;
 L’expression est calculée et ensuite la valeur calculée
est affectée à la variable
Exemple :
x = 3;
x = x + 1;
Initialisation d’une variable

 Une variable doit être initialisée (recevoir une

valeur) avant d’être utilisée dans une expression
 Si elles ne sont pas initialisées par le
programmeur, les variables d’instance (et les
variables de classe étudiées plus loin) reçoivent
les
valeurs par défaut de leur type (0 pour les types
numériques, par exemple)
 L’utilisation d’une variable locale non initialisée
par le programmeur provoque une erreur (pas
d’initialisation par défaut)
 Initialisation d’une variable (2)

On peut initialiser une variable en la déclarant

La formule d’initialisation peut être une expression
complexe :
double prime = 2000.0;
Employe e1 = new Employe("Amrani", "Karim");
double salaire = prime + 5000.0;
Déclaration / création

public static void main(String[] args) {

Employe e1; provoque une erreur
e1.setSalaire(12000); NullPointerException

Il ne faut pas confondre

– déclaration d’une variable et création d’un objet
référencé par cette variable
« Employe e1; »
– déclare que l’on va utiliser une variable e1 qui
référencera un objet de la classe Employe,
– mais aucun objet n’est créé
Déclaration / création (2)
 Il aurait fallu écrire :
public static void main(String[] args) {
Employe e1;
e1 = new Employe("Amrani", "Karim");
e1.setSalaire(12000);
...
}
Désigner les variables d’une
instance
 Soit un objet o1 ; la valeur d’une variable v de
o1 est désignée par o1.v .
Par exemple,
Cercle c1 = new Cercle(p1, 10);
System.out.println(c1.rayon); // affiche 10

Remarque : le plus souvent les variables sont private

et on ne peut y accéder directement en dehors de leur
classe
Accès aux membres d’une classe
 Degrés d'encapsulation
 Java permet plusieurs degrés d’encapsulation pour les
membres (variables et méthodes) et les constructeurs
d’une classe
 L’encapsulation est le fait de ne montrer et de ne
permettre de modifier que ce qui est nécessaire à une
bonne utilisation
Types d'autorisation d'accès
 private : seule la classe dans laquelle il est
déclaré a accès (à ce membre ou constructeur)
 public : toutes les classes sans exception y ont

accès
 Sinon, par défaut, seules les classes du même

paquetage que la classe dans lequel il est déclaré y

ont accès (un paquetage est un regroupement de
classes ; cette notion sera étudiée plus loin dans le
cours)
Granularité de la protection des
attributs d’une classe
 En Java, la protection des attributs se fait classe
par classe, et pas objet par objet
 Un objet a accès à tous les attributs d’un objet de la
même classe, même les attributs privés
Protection de l’état interne d’un
objet
 Autant que possible l’état d’un objet (les
variables) doit être private
 Si on veut autoriser la lecture d’une variable,

on lui associe un accesseur, auquel on donne le

niveau d’accessibilité que l’on veut
 Si on veut autoriser la modification d’une

variable, on lui associe un modificateur, qui

permet la modification tout en contrôlant la
validité de la modification
Désigner l’instance qui reçoit le
message, « this »
Le code d’une méthode d’instance désigne
– l’instance qui a reçu le message (l’instance
courante), par le mot-clé this
– et donc les membres de l’instance courante en les
préfixant par « this. »
Exemple de this implicite
public class Employe {
private double salaire;
...
public void setSalaire(double unSalaire) {
salaire = unSalaire;
} Implicitement
this.salaire
public double getSalaire() {
return salaire;
}
...
}
this explicite
 this est utilisé surtout dans 2 occasions :
– pour distinguer une variable d’instance et un
paramètre qui ont le même nom :
public void setSalaire(double salaire)
this.salaire = salaire;
}
– un objet veut passer une référence de lui-même à un
autre objet :
salaire = comptable.calculeSalaire(this);

Comptable, calcule mon salaire

Autre exemple
public Arbre pousser() {
hauteur ++;
return this;
}
Arbre a = new Arbre();
a.pousser().pousser().pousser();
Interdit de modifier this
 this se comporte comme une variable final (mot-clé
étudié plus loin), c’est-à-dire qu’on ne peut le
modifier ; le code suivant est interdit :
this = valeur;
Méthodes et variables de classe
Variables de classe
 Certaines variables sont partagées par toutes les
instances d’une classe. Ce sont les: variables de classe
(modificateur static)
 Si une variable de classe est initialisée dans sa
déclaration, cette initialisation est exécutée une seule
fois quand la classe est chargée en mémoire
Exemple de variable de classe
public class Employe {
private String nom, prenom;
private double salaire;
private static int nbEmployes = 0;
// Constructeur
public Employe(String n, String p) {
nom = n;
prenom = p;
nbEmployes++;
}
...
}
Méthodes de classe
 Une méthode de classe (modificateur static en Java)
exécute une action indépendante d’une instance
particulière de la classe
 Une méthode de classe peut être considérée

comme un message envoyé à une classe

 Exemple :

public static int getNbEmployes() {

return nbEmployes;
}
Désigner une méthode de classe
 Pour désigner une méthode static depuis une autre
classe, on la préfixe par le nom de la classe :
int n = Employe.getNbEmploye();
 On peut aussi la préfixer par une instance
quelconque de la classe (à éviter car cela nuit à la
lisibilité : on ne voit pas que la méthode est static) :
int n = e1.getNbEmploye();
Méthodes de classe
 Comme une méthode de classe exécute une
action indépendante d’une instance particulière
de la classe, elle ne peut utiliser de référence à
une instance courante (this)
 Il serait, par exemple, interdit d’écrire

static double tripleSalaire() {

return salaire * 3;
La méthode static main
 La méthode main() est nécessairement static.
Pourquoi ?
 La méthode main() est exécutée au début du
programme. Aucune instance n’est donc déjà créée
lorsque la méthode main() commence son exécution.
Ça ne peut donc pas être une méthode d’instance.
Blocs d’initialisation static
 Ils permettent d’initialiser les variables static trop complexes à initialiser
dans leur déclaration :

class UneClasse {
private static int[] tab = new int[25];
static {
for (int i = 0; i < 25; i++) {
tab[i] = -1;
}
}
...
 Ils sont exécutés une seule fois, quand la classe est chargée en mémoire

 Pour désigner la variable static à partir d’une autre classe:

UneClasse.tab[i]
 Exemple de méthode static Math.min()
Exercices

 Reprenez l'exercice précédent, modifier la

classe Rectangle pour qu'il y a 3
constructeurs, un qui ne prend aucun
argument et qui crée un rectangle par défaut,
un qui prend 4 entiers et un qui prend 2 points.
 Pour tester votre classe Rectangle écrire une
méthode main dans laquelle vous créez 2
points p1(2,2) et p2(4,6), créez un rectangle à
partir de ces 2 points, affichez sa surface