Cours : Introduction à la programmation

Cote du cours : 025905

Session : Automne 2021

Chapitre 07
La Programmation Orientée Objet

Table des matières

I. Introduction ......................................................................................................................................... 2
II. Classe : ............................................................................................................................................. 3
1. Déclaration....................................................................................................................................... 4
2. Les champs ...................................................................................................................................... 5
3. Les méthodes ................................................................................................................................... 6
4. Les constructeurs ............................................................................................................................ 9
III. Utilisation d’une classe ................................................................................................................. 10
1. Déclaration de variable................................................................................................................. 10
2. Création de l’objet ........................................................................................................................ 10
3. Utilisation de l’objet ...................................................................................................................... 11
IV. Le mot clé this................................................................................................................................ 13
V. L’encapsulation ................................................................................................................................. 15
VI. Le mot clé static ............................................................................................................................. 16
Correction des exercices ........................................................................................................................... 19

@Mohamed Salah Bouhlel P a g e 1 | 21

I. Introduction

La programmation orientée objet se base sur la notion d’objet qui représente son élément de base.
Un objet peut être assimilé en la combinaison de trois choses :
- Un état : des variables dont les valeurs donnent l’état de l’objet. Ces variables peuvent changer
durant le cycle de vie de l’objet.
Exemple 1 : un étudiant pourrait être caractérisé par :

▪ Un nom : Bouhlel ▪ Un nom : Bourger

▪ Un prénom : Mohamed ▪ Un prénom : Claudine
▪ Un numéro d’inscription : 123456 ▪ Un numéro d’inscription : 521463

Après le mariage de claudine, son nom de famille peut changer.

Exemple 2 : un téléphone intelligent pourrait être caractérisé par :

▪ Capacité de stockage libre : 128 GO ▪ Capacité de stockage libre : 128 GO

▪ OS : Android v10 ▪ OS : iOS
▪ Utilisation : 0 jours ▪ Utilisation : 0 jours

Après l’achat de l’appareil, ces variables (état) vont changer. En ajoutant des données (vidéos,
photos, etc.) la capacité de stockage va diminuer. En mettant à jour votre téléphone, vous pouvez
passer d’une version d’OS à une autre.
- Des comportements : des fonctionnalités offertes par l’objet. En d’autres termes ce que ou ce
qu’on peut faire avec l’objet.
Exemple 1 : un étudiant pourrait

▪ Poser une question Laisser jouer votre imagination pour

▪ Répondre à une question décrire d’autres fonctionnalités.
▪ Passer un examen
▪…

Exemple 2 : un téléphone intelligent pourrait :

▪ Faire un appel Même chose, la liste peut être

▪ Décrocher enrichie.
▪ Prendre photo
▪ Augmenter / diminuer son
▪…

- Une identification : l’identification permet de différencier un objet par rapport aux autres
objets de même type. L’identification est un nom associé à l’objet lors de sa création dont le
but de le gérer (accéder à l’état ou au comportement).

@Mohamed Salah Bouhlel P a g e 2 | 21

Exemple 1

▪ Un nom : Bouhlel ▪ Un nom : Bourger

▪ Un prénom : Mohamed ▪ Un prénom : Claudine
▪ Un numéro d’inscription : 123456 ▪ Un numéro d’inscription : 521463

▪ Poser une question ▪ Poser une question

▪ Répondre à une question ▪ Répondre à une question
▪ Passer un examen ▪ Passer un examen
▪… ▪…
clBourger
moBouhlel

Exemple 2

▪ Capacité de stockage libre : 128 GO ▪ Capacité de stockage libre : 128 GO

▪ OS : Android v10 ▪ OS : iOS
▪ Utilisation : 0 jours ▪ Utilisation : 0 jours

▪ Faire un appel ▪ Faire un appel

▪ Décrocher ▪ Décrocher
▪ Prendre photo ▪ Prendre photo
▪… ▪…

phone1 phone2

L’autre pilier de la programmation objet est la notion de classe. Une classe est une collection
(ensemble) d’objet ayant les mêmes propriétés (état, caractéristiques) et fournissant les mêmes
comportements (fonctionnalités). Techniquement, Les classes sont constituées de champs et de
méthodes. Les champs représentent les caractéristiques des objets dont les valeurs fournissent
l’état. Les méthodes représentent les fonctionnalités offertes par un objet.

II. Classe :

La création d’une classe passe par la déclaration de la classe elle-même et de tous les éléments la
constituant. Ci-dessous la représentation en UML d’une classe. Elle est constituée de 3
compartiments :
- Le nom
- Les propriétés
- Les méthodes

@Mohamed Salah Bouhlel P a g e 3 | 21

 NomDeLaClasse

Les propriétés / champs

Les fonctionnalités / méthodes

1. Déclaration
La déclaration d’une classe se fait en utilisant le mot-clé class suivi du nom de la classe puis d’un
bloc de code délimité par les caractères '{' et '}'.
La syntaxe générale de déclaration d’une classe est donc la suivante1 :

[modificateur] class NomDeLaClasse

[extends NomClasseMere]
[implements NomInterface1, NomInterface2, …]
{
//Code de la classe
}

Les modificateurs permettent de déterminer la visibilité de la classe et la manière de l’utiliser.

Voici la liste des modificateurs disponibles :
• public : nous avons déjà utilisé ce modificateur depuis le début du cours. Il indique que la
classe peut être utilisée par toutes les autres classes. L’absence de ce modificateur indique
que la classe ne sera utilisable que par les classes faisant partie du même package. Plus de
détails dans les parties suivantes.
• abstract : voir chapitre Héritage.

1
Les crochets ([ et ]) indiquent que l’élément est optionnel.

@Mohamed Salah Bouhlel P a g e 4 | 21

 • final : voir chapitre Héritage.
Les mots clé extends et implements seront traités dans le chapitre Héritage.
Exemple 1 : La classe Etudiant
package cours.ch7; Définition du package.
public class Etudiant {
Définition de la classe.
}

Exemple 2 : La classe SmartPhone

package cours.ch7;

public class SmartPhone { La classe doit être enregistrer dans un fichier qui
porte le nom : SmartPhone.java
}

2. Les champs
Les champs, appelés aussi variables membres, de la classe sont définis selon la syntaxe suivante :

[ modificateur ] typeVariable nomVariable;

Plusieurs modificateurs peuvent être appliqués aux champs d’une classe :

- private : La variable n’est accessible que dans la classe ou elle est déclarée.
- protected : La variable est accessible dans la classe ou elle est déclarée, dans les classes du
même package et dans les sous classes. Ce modificateur de visibilité sera traité plus tard dans
le chapitre Héritage.
- public : La variable est accessible partout.
- Si on ne fournit pas de visibilité, alors la variable est accessible dans la classe ou elle est
déclarée et les autres classes du même package.
À part les modificateurs de visibilité, nous avons d’autres modificateurs applicables :
- final : pour définir une constante
- static : pour définir des variables de classe (Voir la fin du chapitre)
- D’autres modificateurs sont applicables, mais vous allez les voir au fur et à mesure que vous
avancez dans l’étude du langage.
La variable doit également avoir un type. Vous pouvez utiliser les types primitifs ou par référence.
Le nom de la variable doit respecter les règles de nommage vu dans le premier chapitre du cours.

@Mohamed Salah Bouhlel P a g e 5 | 21

Exemple 1 : La classe Etudiant
package cours.ch7;

public class Etudiant { Définition de 3 attributs/champs de la classe Etudiant.

private String nom;
private String prenom; Les trois attributs sont privés.
private long numeroInscription;
}

Exemple 2 : La classe SmartPhone

package cours.ch7;

public class SmartPhone {

private int capaciteStockage; Initialisation du champs nombre de jour d’utilisation à 0.
private String oS;
private int nbJoursUtilisation = 0;
private final int dureeDeVie = 3650; La durée de vie de l’appareil est une constante égale à
} 10 ans.

Exercice 1 : Écrire une classe représentant les nombres rationnels nommée Rationnel. Un
rationnel est caractérisé par deux entiers représentant le numérateur et le dénominateur.

Remarque : Les champs d’une classe sont automatiquement initialisés aux valeurs par défaut s’ils
ne sont pas initialisés par le programmeur. Les valeurs par défaut sont les mêmes que celle vue
précédemment et se résume dans le tableau ci-dessous.
Type Valeur par défaut
Les entiers 0
Les réels 0.0
Les booléens false
Les caractères '\u0000'
Les types par référence null

3. Les méthodes
Les méthodes sont simplement des fonctions ou procédures définies à l’intérieur d’une classe. Une
méthode est un bloc d’instructions nommé qui peut (ou non) retourner une valeur représentant le
résultat. Elles sont en général utilisées pour manipuler les champs de la classe. La syntaxe de
déclaration d’une méthode est comme suit :

@Mohamed Salah Bouhlel P a g e 6 | 21

 [ modificateur ] typeRetour nomMethode ( [Arguments] )
[throws Exceptions]
{
//Bloc d<instructions
}

Plusieurs modificateurs peuvent être appliqués aux méthodes d’une classe :

- private : La méthode ne peut être utilisée que dans la classe ou elle est définie.
- protected : La méthode peut être utilisée dans la classe ou elle est définie, dans les classes du
même package et dans les sous classes. Ce modificateur de visibilité sera traité plus tard dans
le chapitre Héritage.
- public : La méthode peut être utilisée partout.
- Si on ne fournit pas de visibilité, alors la méthode est accessible dans la classe ou elle est
définie et les autres classes du même package.
À part les modificateurs de visibilité, nous avons d’autres modificateurs applicables :
- final : voir le chapitre suivant sur Héritage.
- static : pour définir des variables de classe (Voir la fin du chapitre)
- abstract : voir le chapitre suivant sur Héritage.
- D’autres modificateurs sont applicables, mais vous allez les voir au fur et à mesure que vous
avancez dans l’étude du langage.
Le type de retour peut être un type de données primitif ou par référence. Si la méthode n’a pas
d’information à renvoyer (ne retourne rien : affichage à l’écran), vous devez utiliser le mot-
clé void au lieu d’un type de retour. Pour retourner une valeur à l’intérieur d’une méthode, on
utilise le mot-clé return suivi de la valeur à retourner. L’exécution de l’instruction return provoque
l’arrêt de la méthode et le retour vers la méthode appelante.
Les paramètres sont des variables nécessaires au fonctionnement de la méthode. Ces paramètres
sont fournis lors de l’appel à la méthode. Par exemple la méthode max de la classe Math a besoin
de deux paramètres pour calculer le maximum de ces derniers. Son écriture est identique à une
liste de déclaration de variables. La syntaxe est comme suit :
( TypeParam1 nomParam1 , TypeParam2 nomParam2 , … )
Il faut spécifier le type du paramètre et le nom du paramètre. Si plusieurs paramètres sont attendus,
il faut séparer leur déclaration par une virgule. Même si aucun paramètre n’est attendu, les
parenthèses sont tout de même obligatoires.
Le mot-clé throws indique la liste des exceptions que cette méthode peut déclencher lors de son
exécution. La gestion des exceptions sera abordée dans le chapitre Gestion des exceptions.

@Mohamed Salah Bouhlel P a g e 7 | 21

Exemple 1 : La classe Etudiant
package cours.ch7;

public class Etudiant { Méthode ne retournant pas de valeur (void) avec un

private String nom; paramètre de type String.
private String prenom;
private long numeroInscription;

public void poserQuestion(String question){

System.out.println("Je pose une question : "+question);
}
public void repondreQuestion(String question, String reponse){
System.out.println("La réponse à la question " + question +
" est "+ reponse );
}

}
Méthode ne retournant pas de valeur (void) avec deux
paramètres de type String.

Exemple 2 : La classe SmartPhone

package cours.ch7;

public class SmartPhone {
private int capaciteStockage;
private String oS;
private int nbJoursUtilisation = 0;
private final int dureeDeVie = 3650;
Méthode pour afficher les propriétés d’un smartphone.
Ne retourne rien et affiche à l’écran les champs du
smartphone.

public void afficher(){

System.out.println("Les propriétés de mon smartphone : \n" +
"Capacité : "+capaciteStockage+" GO\n" +
"OS = "+oS+"\n" +
"Utilisation : "+nbJoursUtilisation+ "Jours");
}
public void augmenterNombreDeJours(){ Méthode pour augmenter de 1 le nombre de jour
nbJoursUtilisation++; d’utilisation du smartphone.
}
public int getNbJoursUtilisation(){
return nbJoursUtilisation;
}
}
Méthode retournant le nombre de jour d’utilisation du smartphone..

Exercice 2 : Compléter la classe Rationnel en ajoutant les méthodes suivantes :

- Modifier la valeur du numérateur (setNumerateur)
- Modifier la valeur du dénominateur (setDenominateur)
- Récupérer la valeur du numérateur (getNumerateur)
- Récupérer la valeur du dénominateur (getDénominateur)
- Afficher un rationnel sous la forme a / b (afficher)

@Mohamed Salah Bouhlel P a g e 8 | 21

4. Les constructeurs
Le rôle du constructeur est principalement l’initialisation des champs d’une classe. Ils sont appelés
par le programmeur lors de la création d’une instance d’une classe (Objet). Ce sont des méthodes
particulières d’une classe. Les particularités d’un constructeur sont :
- Le constructeur porte le même nom que la classe.
- Le constructeur ne retourne aucun type, même pas void.
- Une classe dispose au moins d’un constructeur. Si aucun n’est fourni, alors le compilateur crée
un constructeur par défaut. Cependant, si le programmeur définit un constructeur, alors le
constructeur par défaut est supprimé.
- Le constructeur peut avoir ou pas des paramètres.
- Une classe peut avoir plusieurs constructeurs : surcharge de constructeur.
- Un constructeur peut en appeler un autre. On parle de chaînage de constructeur.

Définition de la surcharge :
La surcharge d’une méthode consiste en la création de deux ou plusieurs méthodes portant le même
nom mais ayant des paramètres différents. Le type de retour n’intervient pas dans l’opération de
surcharge.

Exemple 1 : La classe Etudiant

package cours.ch7;
Classe Etudiant avec la surcharge de 4
public class Etudiant { constructeurs.
private String nom;
private String prenom;
private long numeroInscription;
Constructeur sans argument
public Etudiant(){}

public Etudiant(String n){

nom = n; Constructeur initialisant le nom.
}

public Etudiant(String n, String p){

nom = n;
prenom = p; Constructeur initialisant le nom et le prénom.
}

public Etudiant(String n, String p, int num){

nom = n;
prenom = p; Constructeur initialisant le nom, le prénom et
numeroInscription = num;
le numéro d’inscription.
}
}

@Mohamed Salah Bouhlel P a g e 9 | 21

Exemple 2 : La classe SmartPhone
package cours.ch7;
Classe SmartPhone avec la surcharge de 2
public class SmartPhone { constructeurs.
private int capaciteStockage;
private String oS;
private int nbJoursUtilisation = 0;
private final int dureeDeVie = 3650;

public SmartPhone(){ }

public SmartPhone(int capacite, String os, int nbj){

capaciteStockage = capacite;
oS = os;
nbJoursUtilisation = nbj;
}
}

Exercice 3 : Compléter la classe Rationnel en ajoutant les constructeurs suivants :

- Sans arguments
- Avec comme argument uniquement le numérateur. Le dénominateur est égal à 1.
- Avec deux arguments : un numérateur et un dénominateur.

III. Utilisation d’une classe

Nous avons déjà utilisé des classes prédéfinies en java tel que le Scanner. L’utilisation d’une classe
respecte les étapes suivantes :
• La déclaration de variable ;
• La création de l’objet ;
• L’utilisation de l’objet.

1. Déclaration de variable
Les variables objet sont des variables de type référence qui diffèrent des variables classiques par
le fait que la variable ne contient pas directement les données, mais seulement une référence sur
l’emplacement dans la mémoire où se trouvent les informations. Comme pour toutes les variables,
elles doivent être déclarées avant leur utilisation. La déclaration se fait de manière identique à celle
d’une variable classique (prenez exemple avec la classe String ou Scanner).

typeVariable nomVariable ;
2. Création de l’objet
La seconde étape consiste à créer l’instance de la classe à travers le mot-clé new. Il est suivi d’un
des constructeurs de la classe. Son rôle est de faire l’allocation mémoire nécessaire pour le
stockage de l’objet. La syntaxe de cette opération est comme suit :

@Mohamed Salah Bouhlel P a g e 10 | 21

 nomVariable = new nomClasse([paramètres]);

Les deux étapes précédentes peuvent être combinées en une seule ligne.

typeVariable nomVariable = new nomClasse([paramètres]);

3. Utilisation de l’objet
Pour utiliser l’objet que nous venons de créer dans l’étape précédente, nous devons utiliser
l’opérateur « . ». Cet opérateur nous donne accès au contenu (attributs et méthode) de notre objet.
La syntaxe d’utilisation est comme suit :

nomVariable.nomMethode([paramètres]);
.
nomVariable.nomAttribut

Cependant, il y a des restrictions relatives à cette utilisation. Ces restrictions sont dues aux
modificateurs de visibilité utilisés :
- Si l’attribut ou la méthode est privé, alors vous ne pouvez pas y accéder à l’extérieur de la
classe.
- Si l’attribut ou la méthode est publique, alors vous pouvez y accéder à l’intérieur ou à
l’extérieur de la classe.

package cours.ch7;

public class Etudiant {

private String nom; Attributs d’instance de la classe Etudiant
private String prenom;
private long numeroInscription;

public Etudiant(){}

public Etudiant(String n){nom = n; }

public Etudiant(String n, String p){

nom = n;
prenom = p; 4 Constructeurs de la classe Etudiant
}

public Etudiant(String n, String p, int num){

nom = n;
prenom = p;
numeroInscription = num;
}

@Mohamed Salah Bouhlel P a g e 11 | 21

 public String getNom() {return nom; }
Méthode d’accès à l’attribut nom
public void setNom(String n) {nom = n; } (lecture = get et écriture = set)
public String getPrenom() { return prenom; }
Méthode d’accès aux attributs
public void setPrenom(String p) {
prénom et numéro d’inscription
prenom = p; }

public long getNumeroInscription() { return numeroInscription; }

public void setNumeroInscription(long ni) {

numeroInscription = ni;
}

public void poserQuestion(String question){

System.out.println("Je pose une question : "+question);
}

public void repondreQuestion(String question, String reponse){

System.out.println("La réponse à la question "+question+ " est "+
reponse );
}
Méthode pour afficher un
public void afficher(){
Etudiant
System.out.println("Nom : "+nom+"\n" +
"Prénom : "+prenom+"\n" +
"Numéro Inscription : "+numeroInscription);
}
}

package cours.ch7;

public class MainEtudiant {

public static void main(String[] args) {
Etudiant e1 = new Etudiant();
Etudiant e2 = new Etudiant("Bouhlel");
Etudiant e3 = new Etudiant("Bouhlel", "Mohamed");
Etudiant e4 = new Etudiant("Bouhlel", "Mohamed", 123456);

e4.afficher();

e2.setPrenom("Marc");
e2.setNumeroInscription(456789);
e2.afficher();

e4.poserQuestion("On peut prendre une pause?");

}
}

L’exécution donne le résultat suivant :

@Mohamed Salah Bouhlel P a g e 12 | 21

En revanche, si j’essaie d’accéder directement à la variable nom, le compilateur affiche une erreur
car l’attribut nom est inaccessible de l’extérieur de la classe.

Exercice 4 : Écrire une classe nommée TestRationnel pour tester la classe Rationnel que nous
avons écrit précédemment.
- Créer 4 rationnels en utilisant différents constructeurs : R1, R2, R3 et R4
- Modifier la valeur du numérateur de R1 et R2
- Modifier la valeur de dénominateur de R3 et R4.
- Afficher les rationnels R1, R2, R3 er R4.

IV. Le mot clé this

Le mot clé this sert à référencer dans une méthode l'instance de l'objet en cours d'utilisation. this
est un objet qui est égal à l'instance de l'objet dans lequel il est utilisé. Il peut être utilisé dans
divers contexte :

1- Lorsqu’un paramètre d’une méthode/constructeur cache en portant le même nom un attribut

d’instance de la classe.

@Mohamed Salah Bouhlel P a g e 13 | 21

package cours.ch7;

public class Etudiant {

private String nom;
private String prenom;
private long numeroInscription; Utilisation de this pour différencier entre le paramètre
et L’attribut d’instance dans le constructeur
public Etudiant(String nom){
this.nom = nom;
}

public void setNom(String nom) { Utilisation de this pour différencier entre le

this.nom = nom; paramètre et L’attribut d’instance dans l’accesseur.
}

public void afficher(){

System.out.println("Nom : "+this.nom+"\n" +
"Prénom : "+this.prenom+"\n" +
"Numéro Inscription : "+this.numeroInscription);
}
}
Aucune obligation d’utiliser le this. Mais il est fortement recommandé de le faire.

2- Pour faire appel à une méthode de la classe courante.

public void afficher(){

System.out.println("Nom : "+this.getNom()+"\n" +
"Prénom : "+this.getPrenom()+"\n" +
"Numéro Inscription : "+this.getNumeroInscription());
}

Appel aux accesseurs des attributs de la classe Etudiant dans la méthode afficher de la classe
Etudiant. L’utilisation n’est pas obligatoire, mais elle est fortement recommandée.

3- Appel à un constructeur de la classe courante.

public Etudiant(String nom){

Constructeur initialisant le nom d’un Etudiant.
this.nom = nom;
}

public Etudiant(String nom, String prenom){

this(nom);
this.prenom = prenom; Utilisation du constructeur précédent (Etudiant(nom)) pour
} définir le second constructeur.

public Etudiant(String nom, String prenom, int numeroInscription){

this(nom, prenom);
this.numeroInscription = numeroInscription;
}
Utilisation du constructeur précédent (Etudiant(nom,prenom)) pour
définir le troisième constructeur.

@Mohamed Salah Bouhlel P a g e 14 | 21

Exercice 5 : Réécrire la classe Rationnel pour utiliser le mot-clé this. On vous demande de
modifier :
- Constructeurs
- Méthodes d’accès
- Affichage
Exercice 6 : Ajouter à la classe rationnel les méthodes suivantes :
- Somme de deux rationnels (somme)
- Produit de deux rationnels (produit)
- Soustraction de deux rationnels (soustraction)
- Inverse d’un rationnel
- Division de deux rationnels
Exercice 7 : Surcharger les méthodes suivantes
- Somme de deux rationnels (somme)
- Produit de deux rationnels (produit)
- Soustraction de deux rationnels (soustraction)
- Division de deux rationnels

V. L’encapsulation

Définition de l’encapsulation 2:
C’est le mécanisme consistant à rassembler les données et les méthodes au sein d'une structure
en cachant l'implémentation de l'objet, c'est-à-dire en empêchant l'accès aux données par un autre
moyen que les services proposés. L'encapsulation permet donc de garantir l'intégrité des données
contenues dans l'objet.

Pour mettre en place le principe d’encapsulation, vous devez :

1- Déclarer vos attributs avec les modificateurs private ou protected mais jamais public.
2- Fournir des méthodes pour accéder au contenu des attributs en lecture et en écriture. En
d’autres termes, définir les accesseurs get et set de chaque attribut.

Exercice 8 : Si ce n’est pas déjà fait, appliquer le principe d’encapsulation sur la classe Rationnel.

2
https://www.commentcamarche.net/contents/808-poo-encapsulation-des-donnees

@Mohamed Salah Bouhlel P a g e 15 | 21

VI. Le mot clé static

Les membres statiques sont des champs ou méthodes qui sont accessibles par la classe elle-même
ou par toutes les instances de la classe. Ils sont utilisés lorsque l’information à gérer est relative à
la classe elle-même et non à une instance particulière.
Les membres (attribut et méthode) statiques, appelés aussi membre de classe, existent en un
exemplaire unique qui est partagé entre toutes les instances (une sorte de variable globale). C’est-
à-dire toutes les instances voient la même valeur du membre statique et que toutes modifications
de cette valeur est visible par toutes les instances.
Pour utiliser un membre statique, on utilise le nom de la classe car toutes les instances fournissent
le même résultat. Cependant, lors de la définition des méthodes statiques, il faut faire attention à
la règle suivante :

Une méthode statique ne peut utiliser que des variables statiques et non des
variables d’instance.

Nous avons travaillé dans le chapitre 3 avec les méthodes statiques dans la classe Math et la classe
String.

Les membres statiques sont déclarés avec le mot-clé static.

[Modificateur] static typeRetour nomMéthode([Params]) { … }

[Modificateur] static typeAttribut nomAttribut [= valeur];

Exemple 1 : La classe Etudiant

Nous voulons mémoriser le nombre d’étudiant qui ont été créés. On commence par définir une
variable statique pour représenter le nombre d’étudiants. À chaque fois qu’on crée un étudiant
(constructeur), on incrémente cette variable. On doit aussi fournir une méthode pour récupérer la
valeur de cette variable.

@Mohamed Salah Bouhlel P a g e 16 | 21

package cours.ch7;
Définition de la variable statique
public class Etudiant {
private static int nbEtudiant = 0;
private String nom, prenom;
private long numeroInscription;

public Etudiant(){ Incrémentation de la variable statique dans le

nbEtudiant++;
} constructeur.

public Etudiant(String nom){

this();
this.nom = nom;
} Chainage de constructeur
public Etudiant(String nom, String prenom){
this(nom);
this.prenom = prenom; Méthode pour retourner le nombre d’étudiant
} qui a été créé.
public Etudiant(String nom, String prenom, int numeroInscription){
this(nom, prenom);
this.numeroInscription = numeroInscription;
}

public static int getNbEtudiant(){

return nbEtudiant;
}
…
}

package cours.ch7;

public class MainEtudiant {

public static void main(String[] args) { Création de 4 étudiants

Etudiant e1 = new Etudiant();

Etudiant e2 = new Etudiant("Bouhlel");
Etudiant e3 = new Etudiant("Bouhlel", "Mohamed");
Etudiant e4 = new Etudiant("Bouhlel", "Mohamed", 123456);

System.out.println("Vous avez créé "+

Etudiant.getNbEtudiant()+" étudiants");
}
}
Appel de la méthode statique par le nom de la classe.

Exercice 8 : Ajouter les méthodes statiques suivantes à votre classe Rationnel

- Somme de deux rationnels
- Produit de deux rationnels

@Mohamed Salah Bouhlel P a g e 17 | 21

Exercice 9 : Écrire une classe nommée testRationnel pour tester toutes les méthodes de la classe
Rationnel.

@Mohamed Salah Bouhlel P a g e 18 | 21

 Correction des exercices

package cours.ch7;

import java.sql.ResultSet;

public class Rationnel {

//Pour respecter le principe d'encapsulation les attributs sont privés
private int numerateur;
private int denominateur;

//Définition des constructeurs

public Rationnel() {
this.denominateur = 1;
}

public Rationnel(int numerateur) {

this();
this.numerateur = numerateur;
}

public Rationnel(int numerateur, int denominateur) {

this.numerateur = numerateur;
this.setDenominateur(denominateur);
}
//Accesseur du numérateur
public int getNumerateur() {
return numerateur;
}

public void setNumerateur(int numerateur) {

this.numerateur = numerateur;
}
//Accesseur du dénominateur
public int getDenominateur() {
return denominateur;
}
//impossible de mettre le dénominateur à 0. Dans ce cas en change la
valeur à 1.
public void setDenominateur(int denominateur) {
if (denominateur == 0) this.denominateur = 1;
else this.denominateur = denominateur;
}

//Méthode pour afficher un Rationnel

public void afficher(){
System.out.println(this.numerateur + " / " + this.denominateur);
}
//Méthode pour calculer la somme de deux rationnels : this + r
public Rationnel somme(Rationnel r){
int numResultat = r.denominateur * this.numerateur + r.numerateur *
this.denominateur;
int denResultat = r.denominateur * this.denominateur;

@Mohamed Salah Bouhlel P a g e 19 | 21

 Rationnel resultat = new Rationnel(numResultat, denResultat);
return resultat;
}
//Méthode pour calculer le produit de deux rationnels : this * r
public Rationnel produit(Rationnel r){
int numResultat = r.numerateur * this.numerateur ;
int denResultat = r.denominateur * this.denominateur;
return new Rationnel(numResultat, denResultat);
}
//Méthode pour calculer l'inverse d'un rationnel : 1/r
public Rationnel inverse(){
return new Rationnel(this.denominateur, this.numerateur);
}
//Méthode pour calculer la division de deux rationnels : this / r= this *
1/r
public Rationnel division(Rationnel r){
return this.produit(r.inverse());
}
//Méthode pour calculer la soustraction de deux rationnels : this - r =
this + (-r)
public Rationnel soustraction(Rationnel r){
return this.somme(new Rationnel(-r.numerateur, r.denominateur));
}

//Surcharge de la méthode somme

public Rationnel somme(int num, int den){
return somme(new Rationnel(num, den));
}
//Surcharge de la méthode produit
public Rationnel produit(int num, int den){
return produit(new Rationnel(num, den));
}

//Surcharge de la méthode division

public Rationnel division(int num, int den){
return division(new Rationnel(num, den));
}
//Surcharge de la méthode soustraction
public Rationnel soustraction(int num, int den){
return soustraction(new Rationnel(num, den));
}
public static Rationnel somme(Rationnel r1, Rationnel r2){
return r1.somme(r2);
}
public static Rationnel produit(Rationnel r1, Rationnel r2){
return r1.produit(r2);
}
}

package cours.ch7;

public class TestRationnel {

public static void main(String[] args) {
Rationnel r1 = new Rationnel();

@Mohamed Salah Bouhlel P a g e 20 | 21

 Rationnel r2 = new Rationnel(5);
Rationnel r3 = new Rationnel(3,7);

//Modifier les valeurs du numérateur et dénominateur de r1

r1.setNumerateur(9);
r1.setDenominateur(7);
//Afficher r1
r1.afficher();

//Modifier le dénominateur de r2
r2.setDenominateur(4);
//Afficher r2
r2.afficher();

//Afficher r3
r3.afficher();

//calculer et afficher la somme de r1 et r2

Rationnel resSomme = r1.somme(r2);
resSomme.afficher();

//Calculer et afficher l'inverse de r1

Rationnel resInverse = r1.inverse();
resInverse.afficher();

//Calculer et afficher le produit de deux rationnel

Rationnel resProduit = r2.produit(r3);
resProduit.afficher();
}
}

@Mohamed Salah Bouhlel P a g e 21 | 21