IFT 6800 – Démonstration 5 But de la démonstration Préalables

Département d’informatique et de
recherche opérationnelle
IFT 6800 – Démonstration 5
But de la démonstration
Cette démonstration est la deuxième partie d’une introduction aux bases du langage Java.
Elle présente les classes et les objets.
Préalables
Révisez les notes de cours des séances 6 et 7 du cours.
Classes et objets
Java est un langage orienté objet, ce qui veut dire que le programmeur définit, crée et
manipule des objets dans son code.
Déclaration de classes
Une classe est la définition d’une structure contenant des champs (des données) est des
méthodes (des fonctions qui agissent sur des données).
Une classe est donc une espèce de patron (« template ») qui permet la création d’objets
(d’instances) qui suivront ce patron. Par exemple, on peut définir la structure de base
d’une classe Chien (taille, race, etc.). Ensuite, il est possible de créer des objets de ce type
Chien, par exemple Fido (petite taille, race terrier), ou Médor (saint-bernard, grande
taille).
Déclaration simple
Avant d’utiliser une classe, il faut définir son type en la déclarant. Rappelez-vous que
toute classe de nom NomClasse doit apparaître dans un fichier NomClasse.java
(attention à la casse).
Pour définir une classe, on écrit le mot-clé class suivi du nom de la classe puis d’un
bloc entre accolades contenant les déclarations de champs et de méthodes. Par exemple,
pour créer un compte bancaire, on peut créer une classe Compte dans un fichier
Compte.java.
class Compte
{
// on met ici des champs et des méthodes
}

2
Champs
Les données d’une classe sont contenues dans des champs, qui sont des variables. La
déclaration se fait en donnant le type du champ suivi de son nom. Par exemple, pour créer
une classe représentant un compte bancaire :
class Compte
{
double solde;
}
Méthodes
La déclaration se fait en donnant le type de retour suivi du nom et de parenthèses
entourant les paramètres. Attention, les parenthèses doivent être présentes même s’il n’y
a pas de paramètres. La déclaration est suivie d’un bloc d’instructions entre accolades qui
définit ce que fait la méthode. La valeur de retour est introduite par le mot-clé return.
Celui-ci peut être omis si le type de retour est void. Par exemple, ajoutons la méthode
setSolde à la classe Compte.
class Compte
{
double solde;
void setSolde( double nouveauSolde )
{
solde = nouveauSolde;
}
}
On peut mettre plusieurs instructions dans un méthode donnée. Ainsi, on peut raffiner
notre méthode setSolde en avertissant le programmeur lorsqu’il donne un solde
négatif à un nouveau compte.
class Compte
{
double solde;
void setSolde( double nouveauSolde )
{
if ( nouveauSolde < 0 )
{
System.err.println( "Nouveau solde négatif !!" );
}
solde = nouveauSolde;
}
}

3
On peut aussi demander le solde dans un objet Compte en créant une méthode
getSolde :
class Compte
{
double solde;
void setSolde( double nouveauSolde )
{
...
}
double getSolde() // pas de paramètres passés à la méthode
{
return solde;
}
}
Les paramètres sont toujours transmis par valeur pour les types de données de base. Par
contre, les instances passées en paramètres sont transmises par référence et sont donc
susceptibles d’être modifiées.
La méthode main
On comprend mieux maintenant la syntaxe de la méthode main de nos programmes
précédents :
public static void main( String[] args )
{
...
}
Pour qu’une classe puisse être exécutée, comme un programme, avec la commande
java NomClasse, il faut que cette méthode se trouve dans la classe NomClasse,
telle quelle.
Constructeurs
Les constructeurs sont des méthodes spéciales qui permettent d’initialiser les champs
d’une classe lorsqu’on crée une instance d’un objet. On les déclare en utilisant le nom de
la classe suivi de parenthèses entourant les paramètres. Par exemple, on peut construire
un nouvel objet Compte en lui donnant un paramètre soldeInitial.

4
class Compte
{
double solde;
Compte( double soldeInitial )
{
solde = soldeInitial;
}
void setSolde( double nouveauSolde )
{
...
}
double getSolde() // pas de paramètres passés à la méthode
{
return solde;
}
}
Contrôle de visibilité
Il existe 4 niveaux de protection des champs et des méthodes d’une classe. Nous en
verrons deux : public et private.
public : La déclaration est introduite par le mot-clé public. Il n’y a aucune
restriction d’accès.
private : La déclaration est introduite par le mot-clé private. Seule la classe peut
voir les champs private et invoquer les méthodes déclarées private. En général on
prévoit des méthodes public d’accès aux données private.
Dans notre exemple, le champ solde doit être caché (private) et n’être accessible
que par les méthodes getSolde et setSolde (qui doivent donc être public).
class Compte
{
private double solde;
public Compte( double soldeInitial )
{
solde = soldeInitial;
}
public void setSolde( double nouveauSolde )
{
...
}
public double getSolde() // pas de paramètres passés à la méthode
{
return solde;
}
}

5
Pour protéger les champs à l’intérieur d’une classe d’une manipulation
erronée ou malveillante par un programmeur, il est fortement recommandé
que ces champs soient déclarés private. On appelle ce principe
l’encapsulation des données. Nous évaluerons ceci lors de la correction de
vos devoirs.
Exercices
1. Créez une classe Chat contenant deux champs : un nom (un champ de type
String) et un age (un champ de type int). Assurez-vous d’utiliser les bonnes
visibilités (public ou private). N’utilisez pas d’accent dans le nom de la variable
age.
Compilez la classe Chat en utilisant le compilateur Java javac. (Avez-vous fait
inclure jdk avant ?). Vous ne pouvez l’exécuter pour le moment.
2. Créez le constructeur de Chat, qui prend en paramètre son nom et son âge. Le
constructeur doit émettre un message d’avertissement si vous donnez un âge inférieur
ou égal à 0.
3. Créez une méthode miaou, qui prend en paramètre un entier n et qui affiche à
l’écran la chaîne « nomDuChat dit Miaou ! » n fois, où nomDuChat est le nom du
chat.
Création d’instances
La création d’une instance se fait via l’opérateur new qui procède à l’allocation de
mémoire et à l’appel d’un constructeur. On crée un nouvel objet de classe NomClasse
avec une instruction ressemblant à ceci :
NomClasse nomVariable = new NomClasse(paramètres du constructeur);
Par exemple, pour créer un objet de type Compte, avec un solde initial de 100 $ on
ferait :
Compte monCompte = new Compte(100.00);
On pourrait aussi faire suivre cette instruction par la création d’un autre compte :
Compte monAutreCompte = new Compte(200.00);
On peut aussi créer des tableaux d’objets, comme on l’a vu dans la section précédente sur
les tableaux :
Compte[] mesComptes = new Compte[2];
mesComptes[0] = new Compte(18.00); // le 1er élément est initialisé
mesComptes[1] = new Compte(135.07); // le 2e élément est initialisé
Accès aux champs et aux méthodes
On accède aux champs et aux méthodes en utilisant la notation pointée.