Les classes

en Java

R. Grin Introduction à Java 53

 Regrouper les objets
 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
R. Grin Introduction à Java 54
 Eléments d’une classe
 Les constructeurs (il peut y en avoir plusieurs)
servent à créer les instances (les objets) 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. Grin Introduction à Java 55
 Exemple : classe Livre
public class Livre {
private String titre, auteur;
private int nbPages;
Variables d’instance
// Constructeur
public Livre(String unTitre, String unAuteur) {
titre = unTitre;
auteur = unAuteur; Constructeurs
}
public String getAuteur() { // accesseur
return auteur;
} Méthodes
public void setNbPages(int nb) { // modificateur
nbPages = nb;
}
}
R. Grin Introduction à Java 56
 Rôles d’une classe
 Une classe est
– un type qui décrit une structure (variables
d’instances) 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
R. Grin Introduction à Java 57
 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 avec les mots
séparés par le caractère souligné « _ » :
UNE_CONSTANTE
 Si possible, des noms pour les classes et des verbes pour les
méthodes
R. Grin Introduction à Java 58
 Les constructeurs

R. Grin Introduction à Java 59

 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 d’instance)
– partage le code qui détermine son
comportement (les méthodes) avec les autres
instances de la classe

R. Grin Introduction à Java 60

 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

R. Grin Introduction à Java 61

 Création d’une instance
public class Employe {
private String nom, prenom; variables
private double salaire; d’instance
// Constructeur
public Employe(String n, String p) {
nom = n;
prenom = p;
}
. . .
public static void main(String[] args) {
Employe e1;
e1 = new Employe("Dupond", "Pierre");
[Link](1200); création d’une instance
. . . de Employe
}
}
R. Grin Introduction à Java 62
 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("Dupond", "Pierre");
e2 = new Employe("Durand", "Jacques", 1500);

R. Grin Introduction à Java 63

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("Dupond", "Pierre");
e2 = new Employe("Durand", "Jacques", 1500);

R. Grin Introduction à Java 64

 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 par
défaut sera :
[public] Classe() { }

Même accessibilité que

la classe (public ou non)

R. Grin Introduction à Java 65

 Les méthodes

R. Grin Introduction à Java 66

 Accesseurs
 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 » ; getter en
anglais
– les accesseurs en écriture, ou modificateurs,
ou mutateurs, pour modifier leur valeur ;
setter en anglais
R. Grin Introduction à Java 67
 Autres types de méthode
 La plupart des méthodes permettent aux
instances de la classe d’offrir des services plus
complexes aux autres instances
 Enfin, des méthodes (private) servent de
« sous-programmes » utilitaires aux autres
méthodes de la classe

R. Grin Introduction à Java 68

 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()
R. Grin Introduction à Java 69
 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)

R. Grin Introduction à Java 70

 Exemples de méthodes
public class Employe { Modificateur
. . .
public void setSalaire(double unSalaire) {
if (unSalaire >= 0.0)
salaire = unSalaire;
}
public double getSalaire() {
return salaire;
} Accesseur
public boolean accomplir(Tache t) {
...
}
}
R. Grin Introduction à Java 71
 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

R. Grin Introduction à Java 72

 Surcharge d’une méthode (2)
 En Java, il est interdit de surcharger une
méthode en changeant seulement 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)
R. Grin Introduction à Java 73
 toString()
 Il est conseillé d’inclure une méthode
toString dans toutes les classes que l’on écrit
 Cette méthode renvoie une chaîne de caractères
qui décrit l’instance
 Une description compacte et précise peut être
très utile lors de la mise au point des
programmes
 [Link](objet) affiche la
valeur retournée par [Link]()
Richard Grin Classes et objets page 74
 Exemple
public class Livre {
...
public String toString() {
return "Livre [titre=" + titre
+ ",auteur=" + auteur
+ ",nbPages=" + nbPages
+ "]";
}
}

Richard Grin Classes et objets page 75

 Les variables

R. Grin Introduction à Java 76

 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
R. Grin Introduction à Java 77
 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

R. Grin Introduction à Java 78

 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
double prime;
Employe e1;
Point centre;

R. Grin Introduction à Java 79

 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;

R. Grin Introduction à Java 80

 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) à la compilation
R. Grin Introduction à Java 81
 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 = 200.0;
Employe e1 = new Employe("Dupond", "Jean");
double salaire = prime + 500.0;

R. Grin Introduction à Java 82

 Déclaration / création
public static void main(String[] args) {
Employe e1;
[Link](1200); provoque une erreur
… NullPointerException
OK ?
}

 Il ne faut pas confondre

– déclaration d’une variable
– 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éé
R. Grin Introduction à Java 83
 Déclaration / création (2)
 Il aurait fallu écrire :

public static void main(String[] args) {

Employe e1;
e1 = new Employe("Dupond", "Pierre");
[Link](1200);
. . .
}

R. Grin Introduction à Java 84

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);
[Link]([Link]); // affiche 10
 Remarque : le plus souvent les variables sont private
et on ne peut pas y accéder directement en dehors de
leur classe

R. Grin Introduction à Java 85

 Accès aux membres d’une classe

R. Grin Introduction à Java 86

 Degrés d’encapsulation

 Java permet plusieurs degrés d’encapsulation

pour les membres (variables et méthodes) et les
constructeurs d’une classe

R. Grin Introduction à Java 87

 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 ; notion étudiée plus loin dans le cours)
 protected sera étudié dans le cours sur
l’héritage
R. Grin Introduction à Java 88
 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

R. Grin Introduction à Java 89

Protection de l’état interne d’un objet
 Autant que possible l’état d’un objet (les
variables d’instance) doit être private
 Si on veut autoriser la lecture d’une variable
depuis l’extérieur de la classe, on lui associe un
accesseur, avec 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
R. Grin Introduction à Java 90
 Exceptions pour les protections
Encore
des variables (à éviter) plus rare !
 Dans de rares cas, on peut autoriser l’accès au
paquetage, ou à tous (public)
– si la variable ne risque pas de recevoir des
valeurs aberrantes
– si l’on veut un accès rapide pour améliorer
les performances
– pour simplifier l’écriture du code qui accède
à la variable
R. Grin Introduction à Java 91
 Désigner l’instance qui reçoit le
message, « this »

R. Grin Introduction à Java 92

 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
– donc, les membres de l’instance courante
en les préfixant par « this. »
 Lorsqu’il n’y a pas d’ambiguïté, this est
optionnel pour désigner un membre de
l’instance courante

R. Grin Introduction à Java 93

 Exemple de this implicite
public class Employe {
private double salaire;
. . .
public void setSalaire(double unSalaire) {
salaire = unSalaire;
}
Implicitement
public double getSalaire() { [Link]
return salaire;
}
. . . Implicitement
[Link]
}
R. Grin Introduction à Java 94
 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)
[Link] = salaire;
}
– un objet passe une référence de lui-même à
un autre objet :
salaire = [Link](this);
Dans quelle classe peut-on Comptable, calcule le salaire de moi
trouver
R. Grin ce code ? Introduction à Java 95
 Autre exemple de this explicite
public class Document {
...
public void imprimer(Imprimante imprimante) {
[Link](this);
}
...

public class Imprimante {

...
public void ajouterRequete(Document doc) {
// Ajoute le fichier associé au document
// dans la file d’attente d’impression
[Link]([Link]());
...

R. Grin Introduction à Java 96

 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;

R. Grin Introduction à Java 97

 Méthodes et variables de classe

R. Grin Introduction à Java 98

 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

R. Grin Introduction à Java 99

 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++;
}
. . .
}
R. Grin Introduction à Java 100
 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;
}

R. Grin Introduction à Java 101

 Désigner une méthode de classe
 Depuis une autre classe, on la préfixe par le
nom de la classe :
int n = [Link]();
 Depuis sa classe, le nom de la méthode suffit
 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 = [Link]();

R. Grin Introduction à Java 102

 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 [Link] * 3;
}

R. Grin Introduction à Java 103

 Méthodes de classe
 Une méthode de classe ne peut avoir la même
signature qu’une méthode d’instance

R. Grin Introduction à Java 104

 Une colle

 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.

R. Grin Introduction à Java 105

 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
R. Grin Introduction à Java 106
 Identificateurs
 Un identificateur Java
– est de longueur quelconque
– commence par une lettre Unicode (caractères
ASCII recommandés)
– peut ensuite contenir des lettres ou des
chiffres ou le caractère souligné « _ »
– ne doit pas être un mot-clé ou les constantes
true, false ou null

R. Grin Introduction à Java 110

 Mots-clés Java
abstract, boolean, break, byte, case, catch, char,
class, const*, continue, default, do, double,
enum**, else, extends, final, finally, float, for,
goto*, if, implements, import, instanceof, int,
interface, long, native, new, null, package,
private, protected, public, return, short, static,
strictfp, super, switch, synchronized, this, throw,
throws, transient, try, void, volatile, while
*: pas encore utilisé
** : depuis Java SE 5
R. Grin Introduction à Java 111
 Commentaires
 Sur une seule ligne :
// Voici un commentaire
int prime = 1500; // prime fin de mois
 Sur plusieurs lignes :
/* Première ligne du commentaire
suite du commentaire */
 Documentation automatique par javadoc
/**
* Cette méthode calcule ...
* Elle utilise ...
*/

R. Grin Introduction à Java 112

 Rappels :
Quelques principes de
programmation

R. Grin Introduction à Java 113

 À ne pas oublier !
 Un programme est écrit une fois
 S’il est utile,
– il sera modifié
– corrigé
– on lui ajoutera des fonctionnalités
– des dizaines (ou centaines) de fois
– sans doute plusieurs années après son
écriture
R. Grin Introduction à Java 114
 Ce qu’il faut rechercher

 Une plus grande facilité de programmation

 Mais surtout
– une maintenance plus aisée
– et une extensibilité accrue

R. Grin Introduction à Java 115

 Comment ?
 Modularité : décomposer en éléments plus
simples
 Encapsulation : cacher ce qu’il n’est pas
indispensable de voir
 Lisibilité : faciliter la compréhension des
programmes
 Réutilisabilité : écrire des modules
réutilisables dans les futurs développements
(difficile)
R. Grin Introduction à Java 116
 Modularité
 Un programme est modulaire s’il est découpé
en modules (plus ou moins) indépendants
 Un bon découpage doit satisfaire les 2 critères :
– forte cohésion des éléments d’un module
– faible couplage entre deux modules différents
 Ces 2 principes favorisent l’utilisation, la
réutilisation et la maintenance des modules :
– plus de souplesse : un module - une fonctionnalité
– les modifications d’un module ont le moins
d’impacts possible sur les autres modules
R. Grin Introduction à Java 117
 Encapsulation
 L’encapsulation est le fait de ne montrer et de
ne permettre de modifier que ce qui est
nécessaire à une bonne utilisation
– on montre l’interface (services offerts) d’un module
– on cache l’implémentation (comment sont rendus
les services)
 Les avantages en sont :
– simplification de l’utilisation (la complexité
d’utilisation ne dépend que de l’interface publique)
– meilleure robustesse du programme
– simplification de la maintenance de l’application
R. Grin Introduction à Java 118