Chapitre 2
Premiers Pas en Programmation Objet :
les Classes et les Objets
Dans la première partie de ce cours, nous avons appris à manipuler des objets de type simple :
entiers, doubles, caractères, booléens. Nous avons aussi appris comment utiliser les tableaux pour sto-
cker des collections d’objets de même type : tableaux d’entiers, tableaux de booléens. . .Cependant, la
majorité des programmes manipulent des données plus complexes. Pour ecrire un logiciel bancaire,
il faudra représenter dans notre langage de programmation l’ensemble des informations caractérisant
un compte et coder les actions qui s’effectuent sur les comptes (retrait, dépot) ; un logiciel de biblio-
thèque devra représenter l’ensemble des informations caractéristiques des livres et coder les opérations
d’ajout ou de retrait d’un livre . . ..
L’approche Orientée Objet, que nous allons aborder dans ce chapitre, consiste à rendre possible dans
le langage de programmation la définition d’objets (des livres, des comptes . . .) qui ressemblent à ceux
du monde réel, c’est à dire caractérisés par un état et un comportement. L’état d’un compte, pourra
être défini par son numéro, le nom de son titulaire, son solde ; son comportement est caractérisé par
les opérations de dépot, de retrait et d’affichage du solde.
Dans nos programmes nous aurons plusieurs objets comptes. Chacuns ont un état qui leur est
propre, mais ils ont les mêmes caractéristiques : ce sont tous des comptes. En programmation Orientée
Objet, nous dirons que ces différents objets comptes sont des objets instances de la classe Compte.
Une classe est un prototype qui définit les variables et les méthodes communes à tous les objets d’un
même genre. Une classe est un patron d’objets. Chaque classe définit la façon de créer et de manipuler
des Objets de ce type.
A l’inverse, un objet est toujours un exemplaire, une instance d’une classe (son patron).
Ainsi, pour faire de la programmation Objet, il faut savoir concevoir des classes, c’est à dire définir
des modèles d’objets, et créer des objets à partir de ces classes.
Concevoir une classe, c’est définir :
1. Les données caractéristiques des objets de la classe. On appelle ces caractéristiques les va-
riables d’instance.
2. Les actions que l’on peut effectuer sur les objets de la classe . Ce sont les méthodes qui peuvent
s’invoquer sur chacuns des objets de la classe.
Ainsi, chaque objet crée possèdera :
1. Un état, c’est à dire des valeurs particulières pour les variables d’instances de la classe auquel
il appartient.
1
2.1. DÉFINIR UNE CLASSE CHAPITRE 2. CLASSES ET OBJETS
2. Des méthodes qui vont agir sur son état.
2.1 Définir une Classe
Une classe qui définit un type d’objet a la structure suivante :
– Son nom est celui du type que l’on veut créer.
– Elle contient les noms et le type des caractéristiques (les variables d’instances) définissant les
objets de ce type.
– Elle contient les méthodes applicables sur les objets de la classe.
Pour définir une classe pour les comptes bancaires on aurait par exemple :
class Compte {
int solde;
String titulaire;
int numero;
void afficher(){
[Link]("solde: "+ [Link]);
}
void deposer(int montant){
[Link] = [Link]+ montant;
}
void retirer(int montant){
[Link]=[Link]-montant;
}
}
2.1.1 Les Variables d’instances
La déclaration d’une variable d’instance se fait comme une déclaration de variable locale au main
ou à un sous programme : on donne un nom, précédé d’un type. La différence est que cette déclaration
se fait au niveau de la classe et non à l’intérieur d’un sous programme.
Nous avons dans la classe Compte 3 variables d’instance : solde destinée à recevoir des entiers,
titulaire destinée à recevoir une chaine de caractères et numero destinée à recevoir des entiers.
Ainsi l’état de chaque objet instance de la classe compte que nous créerons par la suite sera
constitué d’une valeur pour chacune de ces trois variables d’instances. Pour chaque objet instance de
la classe Compte nous pourrons connaitre la valeur de son solde, le nom de son titulaire et le numéro
du compte. Ces valeurs seront propres à chaque objet.
2.1.2 Les méthodes : premier aperçu
Nous n’allons pas dans ce paragraphe décrire dans le détail la définition des méthodes d’objets,
mais nous nous contentons pour l’instant des remarques suivantes : une classe définissant un type
d’objets comportera autant de méthodes qu’il y a d’opérations utiles sur les objets de la classe.
La définition d’une méthode d’objet (ou d’instance) ressemble à la défintion d’un sous pro-
gramme : un type de retour, un nom, une liste d’arguments précédés de leur type. Ce qui fait d’elle une
méthode d’objet est qu’elle ne comporte pas le mot clé static. Ceci (plus le fait que les méthodes
2 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.2. UTILISER UNE CLASSE
sont dans la classe Compte) indique que la méthode va pouvoir être invoquée (appelée) sur n’importe
quel objet de type Compte et modifier son état (le contenu de ses variables d’instances).
Ceci a aussi des conséquences sur le code de la méthode comme par exemple l’apparition du mot
clé this, sur lequel nous reviendrons lorsque nous saurons comment invoquer une méthode sur un
objet.
2.2 Utiliser une Classe
Une fois définie une classe d’objets, on peut utiliser le nom de la classe comme un nouveau type :
déclaration de variables, d’arguments de sous programmes . . .. On pourra de plus appliquer sur les
objets de ce type toutes les méthodes de la classe.
2.2.1 Déclarer des objets instances de la classe
Si la classe Compte est dans votre répertoire de travail, vous pouvez maintenant écrire une autre
classe, par exemple test qui, dans son main, déclare une variable de type Compte :
public class Test {
public static void main (String [] arguments){
Compte c1 = new Compte();
}
}
Comme pour les tableaux, une variable référencant un objet de la classe Compte, doit recevoir
une valeur, soit par une affectation d’une valeur déjà existante, soit en créant une nouvelle valeur avec
new avant d’être utilisée. On peut séparer la déclaration et l’initialisation en deux instructions :
public class Test {
public static void main (String [] arguments){
Compte c1;
c1 = new Compte();
}
}
Après l’exécution de c1 = new Compte(); chaque variable d’instance de c1 a une valeur
par défaut. Cette valeur est 0 pour solde et numero, et null pour titulaire.
2.2.2 Accéder et modifier les valeurs des variables d’instances d’un objet
La classe Compte définit la forme commune à tous les comptes. Toutes les variable de type
Compte auront donc en commun cette forme : un solde, un titulaire et un numéro. En revanche, elles
pourront représenter des comptes différents.
Accéder aux valeurs des variables d’instance
Comment connaître le solde du compte c1 ? Ceci se fait par l’opérateur noté par un point :
public class Test {
public static void main (String [] arguments){
Compte c1 = new Compte();
[Link]([Link]);
NFA032 c CNAM 2012 3
2.2. UTILISER UNE CLASSE CHAPITRE 2. CLASSES ET OBJETS
}
}
La dernière instruction à pour effet d’afficher à l’écran la valeur de la variable d’instance solde de
c1, c’est à dire l’entier 0. Comme le champ solde est de type int, l’expression [Link] peut
s’utiliser partout où un entier est utilisable :
public class Test {
public static void main (String [] arguments){
Compte c1 = new Compte();
int x;
int []tab = {2,4,6};
tab[[Link]]= 3;
tab[1]= [Link];
x = [Link] +34 / ([Link] +4);
}
}
Modifier les valeurs des variables d’instance
Chaque variable d’instance se comporte comme une variable. On peut donc lui affecter une nou-
velle valeur :
public class Test {
public static void main (String [] arguments){
Compte c1 = new Compte();
Compte c2 = new Compte();
[Link] =100;
[Link]=218;
[Link]="Dupont";
[Link] =200;
[Link]=111;
[Link]="Durand";
[Link]
("valeur de c1:" + [Link] + " , "+ [Link] + " ," + [Link]);
[Link]
("valeur de c2:" + [Link] + " , "+ [Link] + " ," + [Link]);
}
}
c1 représente maintenant le compte numero 218 appartenant à Dupont et ayant un solde de 100
euros. et c2 le compte numero 111 appartenant à Durand et ayant un solde de 200 euros.
Affectation entre variables référençant des objets
l’affectation entre variables de types Compte est possible, puisqu’elles sont du même type, mais
le même phenomène qu’avec les tableaux se produit : les 2 variables référencent le même objet et
toute modification de l’une modifie aussi l’autre :
public class TestBis {
public static void main (String [] arguments){
Compte c1 = new Compte();
4 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.2. UTILISER UNE CLASSE
Compte c2 = new Compte();
[Link] =100;
[Link]=218;
[Link]="Dupont";
c2 = c1;
[Link] = 60;
[Link]
("valeur de c1:" + [Link] + " , "+ [Link] + ", " + [Link]);
[Link]
("valeur de c2:" + [Link] + " , "+ [Link] + ", " + [Link]);
}
}
Trace d’exécution :
%> java TestBis
valeur de c1: 60 , Dupont, 218
valeur de c2: 60 , Dupont, 218
2.2.3 Invoquer les méthodes sur les objets.
Une classe contient des variables d’instances et des méthodes. Chaque objet instance de cette
classe aura son propre état, c’est à dire ses propres valeurs pour les variables d’instances. On pourra
aussi invoquer sur lui chaque méthode non statique de la classe. Comment invoque-t-on une méthode
sur un objet ?
Pour invoquer la méthode afficher() sur un objet c1 de la classe Compte il faut écrire :
[Link](); .
Comme l’illustre l’exemple suivant :
public class TestAfficher {
public static void main (String [] arguments){
Compte c1 = new Compte();
Compte c2 = new Compte();
[Link] =100;
[Link]=218;
[Link]="Dupont";
[Link]();
[Link]();
}
}
L’expression [Link](); invoque la méthode afficher() sur l’objet c1. Cela a
pour effet d’afficher à l’écran le solde de c1 c’est à dire 200. L’expression [Link]();
invoque la méthode afficher() sur l’objet c2. Cela affiche le solde de c2 c’est à dire 0.
> java TestAfficher
solde: 100
solde: 0
Ainsi, les méthodes d’objets (ou méthodes non statiques) s’utilisent par invocation sur les objets
de la classe dans lesquelles elles sont définies. l’objet sur lequel on l’invoque ne fait pas partie de la
liste des arguments de la méthode. Nous l’appellerons l’objet courant.
NFA032 c CNAM 2012 5
2.3. RETOUR SUR LES MÉTHODES NON STATIQUES CHAPITRE 2. CLASSES ET OBJETS
2.3 Retour sur les méthodes non statiques
Dans une classe définissant un type d’objet, on définit l’état caractéristiques des objets de la classe
(les variables d’instances) et les méthodes capables d’agir sur l’état des objets (méthodes non sta-
tiques). Pour utiliser ces methodes sur un objet x donné, on ne met pas x dans la liste des arguments
de la méthode. On utilisera la classe en déclarant des objets instances de cette classe. Sur chacun de
ces objets, la notation pointée permettra d’accéder à l’état de l’objet (la valeur de ses variables d’ins-
tances) ou de lui appliquer une des méthodes de la classe dont il est une instance.
Par exemple, si c1 est un objet instance de la classe Compte [Link] permet d’accéder au
titulaire de ce compte, et [Link](800) permet d’invoquer la méthode deposer sur c1.
2.3.1 Les arguments des méthodes non statiques
Contrairement aux sous programmes statique que nous écrivions jusqu’alors, on voit que les mé-
thodes non statiques ont un argument d’entrée implicite, qui ne figure pas parmi les arguments de la
méthode : l’objet sur lequel elle sera appliqué, que nous avons déjà appelé l’objet courant.
Par exemple, la méthode afficher de la classe compte n’a aucun argument : elle n’a besoin
d’aucune information supplémentaire à l’objet courant.
Une méthode d’objet peut cependant avoir des arguments. C’est le cas par exemple de deposer :
on dépose sur un compte donné (objet courant) un certain montant. Ce montant est une information
supplémentaire à l’objet sur lequel s’invoquera la méthode et nécessaire à la réalisation d’un dépot.
Les seuls arguments d’une méthode non statique sont les informations nécessaires à la manipula-
tion de l’objet courant (celui sur lequel on invoquera la méthode), jamais l’objet courant lui même.
2.3.2 Le corps des méthodes non statiques
Les méthodes non statiques peuvent consulter ou modifier l’état de l’objet courant. Celui ci n’est
pas nommé dans la liste des arguments. Il faut donc un moyen de désigner l’objet courant dans le
corps de la méthode.
C’est le role du mot clé this. Il fait référence à l’objet sur lequel on invoquera la méthode. A part
cela, le corps des méthodes non statiques est du code Java usuel.
Par exemple dans la définition de afficher :
void afficher(){
[Link]("solde"+ [Link]);
}
[Link] désigne la valeur de la variable d’instance solde de l’objet sur lequel sera invoqué la
méthode.
Lors de l’exécution de [Link](), this désignera c1, alors que lors de l’exécution de
[Link]() , this désignera c2.
En fait, lorsque cela n’est pas ambigu, on peut omettre this et écrire simplement le nom de la
méthode sans préciser sur quel objet elle est appelée. Pour la méthode afficher cela donne :
void afficher(){
[Link]("solde"+ solde);
}
6 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.3. RETOUR SUR LES MÉTHODES NON STATIQUES
2.3.3 Invocation de méthodes avec arguments
Lorsqu’une méthode d’objet a des arguments, on l’invoque sur un objet en lui passant des valeurs
pour chacun des arguments.
Voici un exemple d’invoquation de deposer :
public class testDepot {
public static void main (String [] arguments){
Compte c1 = new Compte();
[Link] =100;
[Link]=218;
[Link]="Dupont";
[Link]();
[Link](800);
[Link]();
}
}
2.3.4 Lorsque les méthodes modifient l’état de l’objet
La méthode deposer modifie l’état de l’objet courant. L’invocation de cette méthode sur un
objet modifie donc l’état de cet objet. Dans notre exemple d’utilisation, le premier [Link]()
affiche 100, alors que le second [Link]() affiche 900. Entre ces deux actions, l’exécution
de [Link](800) a modifié l’état de c1.
2.3.5 Lorsque les méthodes retournent un résultat
Les méthodes non statiques peuvent evidemment retourner des valeurs. On pourrait par exemple
modifier deposer pour qu’en plus de modifier l’état de l’objet, elle retourne le nouveau solde en
résultat :
class Compte {
int solde;
String titulaire;
int numero;
void afficher(){
[Link]("solde"+ [Link]);
}
int depot(int montant){
[Link] = [Link]+ montant;
return [Link];
}
}
Maintenant, deposer fait 2 choses : tout d’abord elle modifie l’état de l’objet courant, puis elle
retourne l’entier correspondant au nouveau solde. On peut donc utiliser son invocation sur un objet
comme n’importe quelle expression de type int.
Par exemple
public class testDepot {
public static void main (String [] arguments){
NFA032 c CNAM 2012 7
2.4. LES TYPES DES VARIABLES D’INSTANCES PEUVENT
CHAPITRE
ÊTRE DES
2. CLASSES
CLASSESET OBJETS
Compte c1 = new Compte();
[Link] =100;
[Link]=218;
[Link]="Dupont";
[Link]([Link](800));
}
}
2.4 Les types des variables d’instances peuvent être des classes
Lorsqu’on définit un classe, on peut choisir comme type pour les variables d’instances n’importe
quel type existant.
On peut par exemple définir le classe Personne par la donnée des deux variables d’instances,
l’une contenant la date de naissance de la personne et l’autre son nom. La date de naissance n’est pas
un type prédéfini. Il faut donc aussi définir une classe Date
public class Date {
int jour;
int mois;
int annee;
public void afficherDate(){
[Link](
[Link] + " , " + [Link] + " , " + [Link]);
}
// On ne montre pas les autres methodes ...
}
Listing 2.1 – (pas de lien)
public class Personne{
Date naissance;
String nom;
// on ne montre pas les methodes...
}
Lorsqu’on déclare et initialise une variable p2 de type Personne, en faisant :
Personne p2 = new Personne(); l’opérateur new donne des valeurs par défaut à nom et
naissance. Mais la valeur par défaut pour les objets est null, ce qui signifie que la variable
[Link] n’est pas initialisée.
Dès lors, si vous faites [Link] = 18; l’éxecution provoquera la levée d’une ex-
ception :
> java DateTest2
Exception in thread "main" [Link]
at [Link]([Link])
Il faut donc aussi initialiser [Link] :
[Link]= new Date(); avant d’accéder aux champs jour mois et annee.
On peut alors descendre progressivement à partir d’une valeur de type Personne vers les valeurs
des champs définissant le champ Date. Si par exemple p1 est de type Personne alors :
8 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.5. CLASSES ET MÉTHODES STATIQUES
1. [Link] est de type String : c’est son nom.
2. [Link] est de type Date : c’est sa date de naissance.
3. [Link] est de type int : c’est son jour de naissance.
4. [Link] est de type int : c’est son mois de naissance.
5. [Link] est de type int : c’est son annee de naissance.
Le champ naissance d’une personne n’est manipulable que via l’opérateur ., l’affectation et les
méthodes définies pour les dates.
public class PersonneTest {
public static void main (String [] arguments){
Personne p2 = new Personne();
[Link]="toto";
[Link]= new Date();
[Link] = 18;
[Link]([Link]);
[Link] ( [Link] + " date naissance:");
[Link]();
}
}
2.5 Les classes d’objets peuvent aussi avoir des méthodes statiques
Lorsqu’on définit une classe caractérisant un ensemble d’objets, on définit des variables d’instance
et des méthodes non statiques. Ces méthodes définissent un comportement de l’objet courant.
Mais les classe peuvent aussi avoir des méthodes statiques, identiques à celles que nous avons
définies dans les chapitres précédents.
Imaginons par exemple que nous voulions définir dans la classe Date les méthodes bissextile
et longueurMois. Rien ne nous empèche de les définir comme des méthodes statiques.
public class Date {
int jour;
int mois;
int annee;
public void afficherDate(){
[Link](
[Link] + " , " + [Link] + " , " + [Link]);
}
public static boolean bissextile(int a ){
return ((a%4==0) && (!(a%100 ==0) || a%400==0));}
public static int longueur(int m , int a ){
if (m == 1 || m== 3 || m==5 ||m== 7 || m==8|| m==10 || m== 12)
{return 31;}
else if (m==2) {if ( bissextile(a)){return 29;} else {return 28;}}
else {return 30;}
}
}
NFA032 c CNAM 2012 9
2.5. CLASSES ET MÉTHODES STATIQUES CHAPITRE 2. CLASSES ET OBJETS
Déclarer une méthode statique signifie que cette méthode n’agit pas, ni ne connaît en aucune
manière, l’objet courant. Autrement dit, c’est une méthode qui n’agit que sur ses arguments et sur sa
valeur de retour. Techniquement, cela signifie qu’une telle méthode ne peut jamais, dans son corps,
faire référence à l’objet courant, ni aux valeurs de ses variables d’instance.
De la même façon, on ne les invoque pas avec des noms d’objets, mais avec des noms de classe.
Pour longueur, comme elle est dans la classe Date, il faudra écrire :
[Link](12,2000);
Dans la classe Date, on pourra utiliser ces méthodes dans la définition d’autres méthodes, sans
faire référence à la classe Date.
Dans la pratique, on écrit peu de méthodes statiques et beaucoup de méthodes non statiques.
Méthodes statiques et non statiques :
– Les méthodes non statiques définissent un comportement de l’objet courant auquel elles font,
dans leur corps, référence au moyen de this :
public void afficherDate(){
[Link](
[Link] + " , " + [Link] + " , " + [Link]);
}
On les appelle avec des noms d’objets : [Link]();
– Les méthodes statiques ne connaissent pas l’objet courant. Elles ne peuvent faire référence à
this, ni aux variables d’instance.
public static boolean bissextile(int a ){
return ((a%4==0) && (!(a%100 ==0) || a%400==0));}
On les appelle avec un nom de classe : [Link](12,2000);
Maintenant que nous avons bissextile et longueur, nous pouvons définir dans Date la
méthode passerAuLendemain. C’est une méthode d’objet, sans argument qui a pour effet de
modifier l’état de l’objet courant en le faisant passer à la date du lendemain :
public class Date {
int jour;
int mois;
int annee;
public static boolean bissextile(int a ){
return ((a%4==0) && (!(a%100 ==0) || a%400==0));}
public static int longueur(int m , int a ){
if (m == 1 || m== 3 || m==5 ||m== 7 || m==8|| m==10 || m== 12)
{return 31;}
else if (m==2) {if ( bissextile(a)){return 29;} else {return 28;}}
else {return 30;}
}
public void passerAuLendemain(){
if ([Link] < longueur([Link],[Link])){
[Link] = [Link] +1;
}
else if ([Link] == 12) {
[Link] = 1; [Link]=[Link] +1 ;[Link] =1;
}
else {
10 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.6. LES CONSTRUCTEURS.
[Link] = 1 ;[Link] =[Link]+1;
}
}
}
public class Datetest3 {
public static void main (String [] arguments){
Date d2 = new Date();
[Link]=2000;
[Link] =28;
[Link] =2;
[Link]();
[Link]();
[Link]();
}
}
Et voici ce que cela donne lors de l’exécution :
> java Datetest3
28 , 2 , 2000
29 , 2 , 2000
2.6 Les constructeurs.
Revenons un instant sur la création d’objets.
Que se passe-t-il lorsque nous écrivons : Date d1= new Date() ?
L’opérateur new réserve l’espace mémoire nécessaire pour l’objet d1 et initialise les données avec
des valeurs par défaut. Une variable d’instance de type int recevra 0, une de type boolean recevra
false, une de type char recevra ’\0’ et les variables d’instances d’un type objet recevra null.
Nous expliquerons ce qu’est null dans le prochain chapitre. l’opérateur new réalise cela en s’aidant
d’un constructeur de la class Date. En effet, lorsqu’on écrit Date(), on appelle une sorte de mé-
thode qui porte le même nom que la classe. Dans notre exemple, on voit que le constructeur Date qui
est appelé n’a pas d’arguments.
Un constructeur ressemble à une méthode qui porterai le même nom que la classe, mais ce n’est
pas une méthode : la seule façon de l’invoquer consiste à employer le mot clé new suivi de son nom,
c’est à dire du nom de la classe 1 . Ceci signifie qu’il s’exécute avant toute autre action sur l’objet, lors
de la création de l’objet.
2.6.1 Le constructeur par défaut
La classe Date ne contient pas explicitement de définition de constructeur. Et pourtant, nous
pouvons, lors de la création d’un objet, y faire référence après l’opérateur new. Cela signifie que Java
fournit pour chaque classe définie, un constructeur par défaut. Ce constructeur par défaut :
– a le même nom que la classe et
– n’a pas d’argument.
Le constructeur par défaut ne fait pratiquement rien. Voilà a quoi il pourrait ressembler :
1. En fait, on peut aussi l’invoquer dans des constructeurs d’autres classes (cf chapitre sur l’héritage)
NFA032 c CNAM 2012 11
2.6. LES CONSTRUCTEURS. CHAPITRE 2. CLASSES ET OBJETS
public Date(){
2.6.2 Définir ses propres constructeurs
Le point intéressant avec les constructeurs est que nous pouvons les définir nous mêmes. Nous
avons ainsi un moyen d’intervenir au milieu de new, d’intervenir lors de la création des objets, donc
avant toute autre action sur l’objet.
Autrement dit, en écrivons nos propres constructeurs, nous avons le moyen, en tant que concepteur
d’une classe, d’intervenir pour préparer l’objet à être utilisé, avant toute autre personne utilisatrice des
objets.
Sans définir nos propres constructeurs de Date, les objets de types Date commencent mal leur
vie : il naissent avec 0,0,0 qui ne représente pas une date correcte. En effet, 0 ne correspond pas à un
jour, ni à un mois. C’est pourquoi une bonne conception de la classe Date comportera des définitions
de constructeurs.
attention : Dès que nous définissons un constructeur pour une classe, le constructeur par défaut
n’existe plus.
Un constructeur se définit comme une méthode sauf que :
1. Le nom d’un constructeur est toujours celui de la classe.
2. Un constructeur n’a jamais de type de retour.
Dans une classe, on peut définir autant de constructeurs que l’on veut, du moment qu’ils se dif-
férencient par leur nombre (ou le type) d’arguments . Autrement dit, on peut surcharger les construc-
teurs.
Nous pourrions par exemple, pour notre classe Date, définir un constructeur sans arguments qui
initialise les dates à 1,1,1 (qui est une date correcte) :
public class Date {
int jour;
int mois;
int annee;
public Date(){
[Link] =1;
[Link]=1;
[Link] =1;
}
// ....
}
Maintenant, toute invocation de new Date() exécutera ce constructeur.
Il peut aussi être utile de définir un constructeur qui initialise une date avec des valeurs données.
Pour cela, il suffit d’écrire un constructeur avec 3 arguments qui seront les valeurs respectives des
champs. Si les valeurs d’entrée ne représentent pas une date correcte, nous levons une erreur :
public class Date {
// ---Les variables d’instances ---
int jour;
int mois;
12 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.6. LES CONSTRUCTEURS.
int annee;
// ---Les constructeurs ---
public Date(){
[Link] =1;
[Link]=1;
[Link] =1;
}
public Date (int j, int m, int a){
if (m >0 && m<13 && j <=longueur(m,a)){
[Link]=j;
[Link] = m;
[Link] = a;
}
else {
throw new ErreurDate();
}
}
// ---Les methodes ---
public void afficherDate(){
[Link]
([Link] + " , " + [Link] + " , " + [Link]);
}
public int getAnnee(){
return [Link];
}
public void setAnnee(int aa){
[Link]=aa;
}
public void passerAuLendemain(){
if ([Link] < longueur([Link],[Link])){
[Link] = [Link] +1;
}
else if ([Link] == 12) {
[Link] = 1; [Link]=[Link] +1 ;[Link] =1;
}
else {
[Link] = 1 ;[Link] =[Link]+1;
}
}
public static boolean bissextile(int annee ){
return ((annee%4==0) && (!(annee%100 ==0) || annee%400==0));
}
public static int longueur(int m , int a ){
if (m == 1 || m== 3 || m==5 ||m== 7 || m==8|| m==10 || m== 12){
return 31;
}
NFA032 c CNAM 2012 13
2.7. PROTECTION DES DONNÉES CHAPITRE 2. CLASSES ET OBJETS
else if (m==2) {if ( bissextile(a)){return 29;} else {return 28;}}
else {return 30;}
}
}
class ErreurDate extends Error{}
public class datetest4 {
public static void main (String [] arguments){
Date d1 = new Date ();
Date d2 = new Date (2,12,2000);
[Link]();
[Link]();
[Link]();
[Link]();
l’éxécution de datetest4 donne :
> java datetest4
1 , 1 , 1
2 , 12 , 2000
3 , 12 , 2000
Répetons encore une fois que lorsqu’on définit ses propres constructeurs, le constructeur par défaut
n’existe plus. En conséquence, si vous écrivez des constructeurs qui ont des arguments, et que vous
voulez un constructeur sans argument, vous devez l’ecrire vous même.
– Un constructeur :
– est un code qui s’éxécute au moment de la création de l’objet (avec new),
– porte le même nom que la classe,
– ne peut pas avoir de type de retour,
– peut avoir ou ne pas avoir d’arguments,
– sert à initialiser l’état de chaque objet crée.
– Si on ne définit aucun constructeur, il en existe un par défaut, qui n’a pas d’argument.
– Le constructeur par défaut n’existe plus dès que l’on définit un constructeur même si on ne
définit pas de constructeur sans argument.
– 2 constructeurs doivent avoir des listes d’arguments différentes.
2.7 Protection des données
Il est souvent souhaitable de protéger les données contenues dans les variables d’un objet contre
des modifications incontrôlées. Par exemple, pour les comptes bancaires, le numéro de compte ne doit
pas changer. Il faut le protéger contre une affectation opérée par erreur ou par malveillance. Seul le
constructeur doit affecter une valeur à ce numéro. Dans ce même exemple, il faut aussi éviter des
modifications du solde par une affectation. Affecter un montant à la variable solde ne correspond à
aucune opération bancaire. Toute modification de solde doit se faire via les opérations de dépôt et
retrait.
Pour assurer cette protection des données, il existe la possibilité de déclarer les variables comme
privées, c’est-à-dire qu’on ne peut les utiliser qu’à l’intérieur de la classe. On utilise pour cela le
mot-clé private.
14 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.7. PROTECTION DES DONNÉES
Pour permettre de connaître la valeur d’une variable privée sans permettre de la modifier, on peut
écrire une méthode qui renvoie la valeur de la variable. Une telle méthode s’appelle un accesseur.
class Compte {
private int solde;
private String titulaire;
private int numero;
Compte (int num, String tit){
titulaire = tit;
numero = num;
solde = 0;
}
int getNumero(){
return numero;
}
String getTitulaire(){
return titulaire;
}
int getSolde(){
return solde;
}
void afficher(){
[Link]("solde"+ [Link]);
}
void deposer(int montant){
[Link] = [Link]+ montant;
}
void retirer(int montant){
[Link]=[Link]-montant;
}
}
Si maintenant, dans une autre classe, on essaie de modifier le contenu d’une variable par une
affectation, cela cause une erreur.
public class Autre{
public static void main(String[] args){
Compte c1 = new Compte(100010,"Christian");
[Link] = 100;
[Link] = 1;
[Link] = "Charles";
}
}
> javac [Link]
[Link][Link] solde has private access in Compte
[Link] = 100;
^
[Link][Link] numero has private access in Compte
[Link] = 1;
^
[Link][Link] titulaire has private access in Compte
NFA032 c CNAM 2012 15
2.8. LES VARIABLES STATIQUES (OU DE CLASSE) CHAPITRE 2. CLASSES ET OBJETS
[Link] = "Charles";
^
3 errors
Le contenu des variables peut être connu au moyen des méthodes getNumero, getTitulaire
et getSolde, mais il ne peut pas être changé, sauf le solde qui peut changer via les appels aux mé-
thodes retirer et deposer.
On utilise le mot-clé public pour permettre l’utilisation d’une composante (variable ou mé-
thode) par n’importe quelle classe. Ce mot-clé s’oppose à private. Si l’on ne précise rien (ni public,
ni private), l’effet est intermédiaire : le composant est utilisable par certaines autres classes mais pas
toutes.
En pratique, toute variable d’instance est normalement private. Les méthodes et constructeurs
de la classes sont généralement déclarés public.
Une classe typique a donc la forme :
public class Personne {
private String nom; // ne change pas une fois l’objet créé
private String prenom; // ne change pas une fois l’objet créé
private String adresse; // peut changer une fois l’objet créé
public Personne(String nom, String prenom, String adresse) {
[Link]= nom;
[Link]= prenom;
[Link]= adresse;
}
public String getNom() {
return nom;
}
public String getPrenom() {
return prenom;
}
public String getAdresse() {
return adresse;
}
public void setAdresse(String adresse) {
[Link]= adresse;
}
}
2.8 Les variables statiques (ou de classe)
Nous savons déjà que les classes peuvent contenir
1. des variables d’instances
2. des constructeurs
3. des méthodes statiques ou non statiques.
16 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.8. LES VARIABLES STATIQUES (OU DE CLASSE)
Les classes peuvent contenir une quatrième sorte d’éléments : des variables statiques.
2.8.1 Déclaration de variables statiques
On les declarent en faisant précéder la déclaration usuelle du mot clé static. Par exemple :
static int a;
A titre d’exemple, ajoutons à la classe Date une variable statique nb :
Listing 2.2 – (pas de lien)
public class Date {
// ---Les variables d’instances ---
int jour;
int mois;
int annee;
// ---La variable statique ---
static int nb ;
// ---le reste est inchange ___
...
2.8.2 Rôle et comportement des variables statiques
Chaque objet à sa propre copie des variables d’instances. Elles représentent l’état personnel de
l’objet. En revanche, il y a une seule copie des variables d’instances par classe. Tous les objets ins-
tances de la classe partagent la même copie. On peut accéder au contenu des variables d’instances
par la classe ou par les objets instances de la classe. Et voici des exemples d’utilisation de la variable
statique nb ajoutée à la classe Date :
class public class TestStatic {
public static void main (String [] arguments){
Date d1= new Date(1,1,2000);
Date d2 = new Date(2,2, 2004);
[Link]([Link]); // acces a nb par la classe Date.
[Link]([Link]); // acces a nb par une variable d’instance
[Link]([Link]); // acces a nb par une autre variable d’instance
[Link] = 2;
[Link] ([Link] + ", " + [Link] + " , " + [Link]);
[Link] = 1;
[Link] = 23;
[Link] ([Link] + ", " + [Link] + " , " + [Link]);
[Link] ( [Link] + " , " + [Link]);
}
}
produit :
simonot@jupiterd:> java TestStatic
0
0
0
NFA032 c CNAM 2012 17
2.9. RÉSUMÉ CHAPITRE 2. CLASSES ET OBJETS
2, 2 , 2
1, 1 , 1
23 , 2
Cet exemple nous montre bien que les variables statiques sont globales à tous les objets instances
d’une classe : à chaque instant [Link] et [Link] et [Link] ont la même valeur, contrairement aux
variables d’instances dont les valeurs sont personnelles à chaque objet. Ainsi, dans une classe, nous
avons deux sortes d’éléments :
– les variables d’instances et les méthodes non statiques qui agissent sur les variables d’instances
propres à chaque objet. C’est pourquoi ces méthodes sont aussi appelées méthodes d’instances.
Chaque objet crée a sa propre copie des variables et méthodes d’instances.
– Les variables et méthodes statiques, dites aussi variables et méthodes de classe. Une seule et
même copie de ces éléments est partagée par tous les objets de la classe.
Les variables de classe, comme nb sont bien sur accessibles dans la classe ou elles sont définies
et en particulier dans les méthodes de la classe. Ce sont des variables globales à la classe.
2.9 Résumé
– Une classe est un patron d’objet qui définit :
1. Les données caractéristiques des objets : les variables d’instances.
2. Les constructeurs permettant d’initialiser les objets lors de leur création. (facultatif)
3. le comportement des objets : les méthodes que l’on pourra invoquer sur les objets.
– Un objet est une instance d’une classe.
1. On les créé en faisant new suivi d’un appel de constructeur : Date d1 = new Date();
Date d2 = new Date(12, 6,2003);
2. Ils ont leur propres valeurs pour chacune des variables d’instances.
3. On peut leur appliquer les méthodes de la classe dont ils sont l’instance : [Link]();
.
– Les méthodes non statiques définissent un comportement de l’objet courant auquel elles font,
dans leur corps, référence au moyen de this :
public void afficherDate(){
[Link](
[Link] + " , " + [Link] + " , " + [Link]);
}
On les appelle avec des noms d’objets : [Link]();
– Les méthodes statiques ne connaissent pas l’objet courant. Elles ne peuvent faire référence à
this, ni aux variables d’instances.
public static boolean bissextile(int a ){
return ((a%4==0) && (!(a%100 ==0) || a%400==0));}
On les appelle avec un nom de classe : [Link](12,2000);
– Un constructeur :
– est un code qui s’éxécute au moment de la création de l’objet (avec new)
– porte le même nom que la classe,
– ne peut pas avoir de type de retour,
– peut avoir ou ne pas avoir d’argument,
18 NFA032 c CNAM 2012
CHAPITRE 2. CLASSES ET OBJETS 2.9. RÉSUMÉ
– sert à initialiser l’état de chaque objet crée.
– Si on ne définit aucun constructeur, il en existe un par défaut, qui n’a pas d’arguments.
– Le constructeur par défaut n’existe plus dès que l’on définit un constructeur.
– 2 constructeurs doivent avoir des listes d’arguments différentes (par le nombre et/ou par le type
des arguments).
NFA032 c CNAM 2012 19
