programmation orientée objet (POO) en Java
En programmation orientée objet (POO) en Java, une classe est un modèle ou un plan pour
créer des objets, tandis qu'un objet est une instance spécifique d'une classe. Une classe
définit les caractéristiques (attributs) et les comportements (méthodes) que les objets de
cette classe auront.
Voici une explication plus détaillée :
Classe : Une classe est une structure qui définit un modèle pour créer des objets. Elle spécifie
les attributs (variables) que chaque objet de cette classe possédera, ainsi que les méthodes
(fonctions) qui définissent le comportement de ces objets. Une classe est essentiellement
une définition abstraite.
Objet : Un objet est une instance concrète d'une classe. Il est créé en utilisant le constructeur
de la classe. Chaque objet a ses propres valeurs d'attributs, mais partage les mêmes
méthodes définies dans la classe. Les objets sont utilisés pour représenter des entités réelles
ou abstraites dans votre programme.
Exemple :
Voici un exemple simple d'une classe Personne et d'un objet personne1 de cette classe en
Java :
public class Personne {
// Attributs
private String nom;
private int age;
// Constructeur
public Personne(String nom, int age) {
[Link] = nom;
[Link] = age;
// Getter pour obtenir le nom
public String getNom() {
return nom;
}
// Setter pour modifier le nom
public void setNom(String nom) {
[Link] = nom;
// Getter pour obtenir l'âge
public int getAge() {
return age;
// Setter pour modifier l'âge
public void setAge(int age) {
if (age >= 0) {
[Link] = age;
} else {
[Link]("L'âge ne peut pas être négatif.");
// Méthode pour afficher les informations de la personne
public void afficherInformations() {
[Link]("Nom : " + nom);
[Link]("Âge : " + age + " ans");
// Méthode pour souhaiter un anniversaire
public void souhaiterAnniversaire() {
age++;
[Link]("Joyeux anniversaire !");
}
Dans cet exemple, Personne est une classe qui définit une personne avec des attributs
(nom et âge) et des méthodes (afficherInformations et souhaiterAnniversaire).
Concept des Getters et Setters :
Les getters sont des méthodes qui permettent d'obtenir la valeur d'un attribut d'une
classe. Ils sont généralement utilisés pour accéder à des attributs privés depuis
l'extérieur de la classe, car les attributs privés ne sont pas accessibles directement.
Les setters sont des méthodes qui permettent de modifier la valeur d'un attribut d'une
classe. Ils sont utilisés pour définir ou mettre à jour la valeur d'un attribut privé depuis
l'extérieur de la classe. Les setters permettent de contrôler et de valider les valeurs
assignées aux attributs.
Maintenant, créons un objet personne1 de la classe Personne :
public class Exemple {
public static void main(String[] args) {
// Créez un objet personne1 en utilisant le constructeur
Personne personne1 = new Personne("Alice", 30);
// Utilisez les getters pour obtenir les informations de la personne
String nomPersonne1 = [Link]();
int agePersonne1 = [Link]();
[Link]("Nom : " + nomPersonne1);
[Link]("Âge : " + agePersonne1 + " ans");
// Utilisez les setters pour mettre à jour les informations de la personne
[Link]("Alice Smith");
[Link](31); // Essayez également de mettre un âge négatif pour tester la
validation
// Appelez la méthode pour afficher les informations de la personne
[Link](); // Affiche les informations mises à jour
}
}
Dans cet exemple, personne1 est un objet de la classe Personne. Nous l'avons créé en
utilisant le constructeur de la classe Personne, puis nous avons appelé des méthodes sur
cet objet pour afficher des informations et souhaiter un anniversaire.
Structures de stockages des objets crées
Pour stocker plusieurs personnes dans un tableau (ou un ArrayList, qui est plus flexible
qu'un tableau standard), vous pouvez procéder comme suit. Voici un exemple utilisant un
ArrayList pour stocker plusieurs objets Personne :
import [Link];
import [Link];
public class GestionnairePersonnes {
public static void main(String[] args) {
// Créez un ArrayList de Personne pour stocker plusieurs personnes
List<Personne> personnes = new ArrayList<>();
// Ajoutez des personnes à la liste
[Link](new Personne("Alice", 30));
[Link](new Personne("Bob", 25));
[Link](new Personne("Charlie", 35));
// Utilisez une boucle pour parcourir la liste et afficher les informations de chaque
personne
[Link]("Informations sur les personnes :");
for (Personne personne : personnes) {
[Link]("Nom : " + [Link]());
[Link]("Âge : " + [Link]() + " ans");
[Link](); // Ligne vide pour la séparation
CE qui est demandé
Exercice : Gestionnaire de Comptes Bancaires
Objectif : Créer une classe Banque pour gérer des comptes bancaires.
Description :
[Link]éez une classe CompteBancaire avec les attributs suivants :
numeroCompte (un identifiant unique pour chaque compte)
nomTitulaire (nom du titulaire du compte)
solde (solde actuel du compte)
La classe CompteBancaire doit avoir un constructeur pour initialiser les attributs.
[Link] des méthodes dans la classe CompteBancaire :
deposer(double montant) : pour déposer de l'argent sur le compte.
retirer(double montant) : pour retirer de l'argent du compte (vérifiez que le solde est
suffisant).
getSolde() : pour obtenir le solde actuel.
[Link]éez une classe Banque pour gérer une liste de comptes bancaires.
Ajoutez une méthode ajouterCompte(CompteBancaire compte) pour ajouter un
compte à la liste.
Ajoutez une méthode getCompteByNumero(int numeroCompte) pour obtenir un
compte par son numéro.
Dans la méthode main, créez une instance de Banque et effectuez des opérations telles que
la création de comptes, les dépôts et les retraits.
Modificateurs d'accès :
Objectif : Comprendre l'utilisation des modificateurs d'accès (public, private, protected) et des
modificateurs d'attributs (final, static) en Java.
Les modificateurs d'accès sont des mots-clés utilisés en programmation pour définir la
visibilité et l'accès aux classes, aux attributs et aux méthodes d'une classe. En Java, il existe
quatre principaux modificateurs d'accès :
public : Les éléments déclarés avec le modificateur public sont accessibles de n'importe où,
à l'intérieur ou à l'extérieur de la classe. Par exemple, une méthode public peut être appelée
depuis n'importe quelle classe.
private : Les éléments déclarés avec le modificateur private sont accessibles uniquement à
l'intérieur de la classe où ils sont définis. Ils ne peuvent pas être directement accessibles
depuis l'extérieur de la classe. Pour accéder à ces éléments depuis l'extérieur, des méthodes
publiques (getters et setters) sont généralement utilisées.
protected : Les éléments déclarés avec le modificateur protected sont accessibles dans la
classe où ils sont définis, ainsi que dans les sous-classes (classes dérivées) de cette classe.
Cependant, ils ne sont pas accessibles depuis l'extérieur de la classe ou de ses sous-classes.
package-private (ou sans modificateur) : Lorsqu'aucun modificateur d'accès n'est spécifié
(c'est-à-dire que vous n'utilisez aucun des trois modificateurs ci-dessus), l'élément est
accessible uniquement dans le même package (ensemble de classes dans le même
répertoire). Il n'est pas accessible depuis l'extérieur du package.
Modificateurs de Méthodes :
Les modificateurs de méthodes sont utilisés pour définir le comportement et la visibilité des
méthodes d'une classe. Les principaux modificateurs de méthodes en Java sont :
public : Une méthode déclarée comme public est accessible depuis n'importe où, à
l'intérieur ou à l'extérieur de la classe. C'est le niveau d'accès le plus permissif pour une
méthode.
private : Une méthode déclarée comme private est accessible uniquement à l'intérieur de la
classe où elle est définie. Elle ne peut pas être appelée depuis l'extérieur de la classe.
protected : Une méthode déclarée comme protected est accessible dans la classe où elle
est définie, ainsi que dans les sous-classes (classes dérivées) de cette classe. Elle n'est pas
accessible depuis l'extérieur de la classe ou de ses sous-classes.
package-private (ou sans modificateur) : Lorsqu'aucun modificateur n'est spécifié pour
une méthode (c'est-à-dire que vous n'utilisez aucun des trois modificateurs ci-dessus), la
méthode est accessible uniquement dans le même package (ensemble de classes dans le
même répertoire). Elle n'est pas accessible depuis l'extérieur du package.
Les modificateurs d'accès et de méthodes sont essentiels pour définir l'encapsulation et le
contrôle d'accès dans la programmation orientée objet, ce qui permet de gérer efficacement la
visibilité et l'accès aux éléments d'une classe.
Exemple : Modificateurs d'Accès et Modificateurs d'Attributs
Créez une classe Personne avec les attributs suivants :
nom (de type String)
age (de type int)
sexe (de type char)
Ajoutez des modificateurs aux attributs pour définir les restrictions d'accès suivantes :
nom : public
age : private
sexe : protected
Écrivez un constructeur par défaut qui initialise les attributs à des valeurs par défaut.
Créez des méthodes publiques getNom(), getAge(), et getSexe() pour permettre aux autres
classes d'accéder aux attributs de la classe Personne.
Créez des méthodes publiques setNom(), setAge(), et setSexe() pour permettre aux autres
classes de modifier les attributs de la classe Personne.
Dans la classe principale (classe contenant la méthode main), créez un objet Personne et
utilisez les méthodes getters et setters pour accéder et modifier les attributs de l'objet.
Utilisez un modificateur final pour définir une constante nommée MAJORITE avec la valeur
18 qui représente l'âge légal de la majorité.
Créez une méthode publique estMajeur() dans la classe Personne qui utilise MAJORITE pour
vérifier si une personne est majeure.
Dans la classe principale, utilisez la méthode estMajeur() pour vérifier si une personne est
majeure ou non.
Le code:
public class Personne {
public String nom;
private int age;
protected char sexe;
// Constructeur par défaut
public Personne() {
nom = "Nom par défaut";
age = 0;
sexe = 'N';
// Méthodes getters
public String getNom() {
return nom;
public int getAge() {
return age;
public char getSexe() {
return sexe;
// Méthodes setters
public void setNom(String nouveauNom) {
nom = nouveauNom;
public void setAge(int nouvelAge) {
age = nouvelAge;
public void setSexe(char nouveauSexe) {
sexe = nouveauSexe;
}
// Méthode pour vérifier si la personne est majeure
public boolean estMajeur() {
final int MAJORITE = 18;
return age >= MAJORITE;
public static void main(String[] args) {
Personne personne1 = new Personne();
[Link](25);
[Link]("Nom : " + [Link]());
[Link]("Age : " + [Link]());
[Link]("Sexe : " + [Link]());
if ([Link]()) {
[Link]("Cette personne est majeure.");
} else {
[Link]("Cette personne n'est pas majeure.");
CE qui est demandé
Objectif : Créer une classe Livre pour représenter un livre et une classe Bibliothèque pour
gérer une collection de livres.
Description :
Créez une classe Livre avec les attributs suivants :
titre (String) - Le titre du livre.
auteur (String) - L'auteur du livre.
disponible (boolean) - Indique si le livre est disponible ou emprunté.
1. Utilisez les modificateurs d'accès appropriés pour les attributs de la classe Livre.
2. Ajoutez des méthodes getters et setters pour les attributs titre, auteur, et disponible.
3. Créez une classe Bibliothèque avec une liste (par exemple, ArrayList) de livres.
4. Utilisez les méthodes de la classe ArrayList pour ajouter, supprimer et parcourir la liste
de livres dans la classe Bibliothèque.
5. Ajoutez une méthode emprunterLivre(String titre) à la classe Bibliothèque qui marquera
un livre comme "non disponible" lorsqu'il est emprunté.
6. Ajoutez une méthode retournerLivre(String titre) à la classe Bibliothèque qui marquera
un livre comme "disponible" lorsqu'il est retourné.
7. Dans la classe principale (classe contenant la méthode main), créez une instance de
Bibliothèque, ajoutez quelques livres à la bibliothèque, empruntez et retournez des livres,
puis affichez l'état de la bibliothèque.
L’héritage:
En programmation orientée objet (POO), l’héritage est un mécanisme qui permet de créer de
nouvelles classes à partir de classes existantes. Il permet à une classe, appelée classe
dérivée, d’acquérir les caractéristiques d’une autre classe, appelée classe de base.
La classe dérivée hérite des propriétés de la classe de base, c’est-à-dire des données et des
fonctions membres. Ainsi, il est possible de compléter des classes en ajoutant des données
ou des fonctions membres, et/ou de les personnaliser en redéfinissant des données (valeurs)
ou des fonctions membres.
Pour savoir s’il y a une relation d’héritage entre deux classes, il suffit de suivre cette règle très
simple : il y a héritage quand on peut dire : "A est un B".
L’héritage permet de réutiliser le code existant et de le modifier ou de l’étendre pour
répondre à de nouveaux besoins. C’est un concept fondamental en POO qui favorise la
modularité et la réutilisation du code.
TP3: Gestion de Magasin avec Héritage
Partie 1 : Définition des classes de base
Définissez une classe de base appelée Produit avec les attributs (ID, nom, Quantity, prix,
dispo). Cette classe doit avoir un constructeur pour initialiser les attributs, en mettant dispo
à true par défaut et les getters et les setters.
Ajoutez une méthode afficherProduit() ,dans la classe Produit pour afficher les détails du
produit et des méthodes qui gères le vente et l’achat.
Créez une classe Magasin avec une liste de produits, et qui implémente les méthodes
appropriées.
Partie 2 : Implémentation de l'héritage
Créez des sous-classes de Produit pour différentes catégories de produits. Par exemple,
vous pouvez avoir des sous-classes telles que Aliment, Vêtement, Électronique, etc.
Chaque sous-classe doit avoir des attributs spécifiques à sa catégorie. Par exemple, la
classe Aliment peut avoir un attribut dateExpiration, la classe Vêtement peut avoir un
attribut taille, etc.
Ajoutez des constructeurs pour chaque sous-classe afin d'initialiser les attributs
spécifiques de la catégorie.
Redéfinissez la méthode afficherProduit() dans chaque sous-classe pour afficher les
détails spécifiques de la catégorie.
Partie 3 : Utilisation dans le Magasin
Modifiez la classe Magasin pour qu'elle puisse gérer des produits de différentes
catégories.
Ajoutez des méthodes dans la classe Magasin pour ajouter des produits de différentes
catégories à la liste (en spécifiant la disponibilité par défaut), supprimer des produits, et
afficher tous les produits disponibles.
Appliquez un solde spécifique à chaque type de produit en utilisant la méthode
appliquerSolde() de la Classe produit et Ajoutez la méthode SoldeGlobale() de la Classe
Magasin
Partie 4 : Test de l'héritage
Dans le programme principal, créez quelques instances de produits de différentes
catégories et ajoutez-les au magasin.
Créer un menu qui gère tous les actions possibles tel que:
***Afficher la liste des produits, Ajouter un nouveau produit, Supprimer un produit
Affichez la liste des produits après solde…
1. Les Classes Abstraites en Java:
Une classe abstraite est une classe dans la programmation orientée objet qui ne peut pas
être instanciée directement, c'est-à-dire qu'on ne peut pas créer d'objets à partir de cette
classe. Elle sert souvent de modèle pour d'autres classes, appelées classes dérivées ou sous-
classes. La classe abstraite peut contenir à la fois des méthodes abstraites et des méthodes
concrètes.
Une méthode abstraite est une méthode déclarée dans une classe abstraite qui n’a pas
d’implémentation par défaut. Elle est simplement définie (son nom, ses paramètres et son
type de retour) mais pas implémentée. Les classes qui héritent de la classe abstraite doivent
fournir une implémentation concrète pour toutes les méthodes abstraites de la classe
parent.
Voici quelques points importants à retenir sur les classes abstraites en Java:
Une classe abstraite doit être déclarée avec le mot-clé abstract.
Elle ne peut pas être instanciée, c’est-à-dire que vous ne pouvez pas créer un objet d’une
classe abstraite directement.
Elle peut avoir des méthodes abstraites et non abstraites.
Elle peut avoir des constructeurs et des méthodes statique.
Elle peut avoir des méthodes finales qui forceront la sous-classe à ne pas changer le
corps de la méthode.
Si une classe contient au moins une méthode abstraite, alors la classe doit être déclarée
abstraite.
L’utilité d’une classe abstraite en Java, ou dans tout autre langage de programmation orienté
objet, est multiple :
1. Définir un contrat pour les classes dérivées : Une classe abstraite permet de définir un
ensemble de méthodes abstraites que toutes les classes dérivées doivent implémenter.
Cela garantit une cohérence dans la manière dont les méthodes sont utilisées et
implémentées.
2. Réutilisation du code : Les classes abstraites peuvent contenir des méthodes concrètes
avec une implémentation qui peut être réutilisée par les classes dérivées. Cela évite la
duplication de code et favorise la maintenance.
3. Polymorphisme : Les classes abstraites permettent le polymorphisme. On peut utiliser
des références de type classe abstraite pour pointer vers des objets de classes dérivées,
ce qui permet de traiter différents types d’objets de manière uniforme.
4. Encapsulation : Les classes abstraites peuvent servir à cacher certains détails
d’implémentation et à exposer uniquement les fonctionnalités pertinentes à travers des
méthodes abstraites.
5. Extension facile : Les classes abstraites facilitent l’extension du code existant. On peut
créer de nouvelles classes qui héritent de la classe abstraite sans modifier son code
source.
En somme, les classes abstraites sont un outil puissant pour la conception de logiciels,
permettant de créer des architectures robustes et évolutives.
Exemple
Voici un exemple simple d’une classe abstraite en Java:
public abstract class Vehicule {
private String marque;
// Méthode abstraite
public abstract void demarrer();
// Méthode concrète avec définition
public String getMarque() {
return marque;
}
public void setMarque(String marque) {
[Link] = marque;
}
}
Dans cet exemple, Vehicule est une classe abstraite qui contient une méthode abstraite
demarrer() et des méthodes concrètes pour obtenir et définir la marque du véhicule. Les
classes qui héritent de Vehicule doivent fournir une implémentation pour la méthode
demarrer(). Cela permet de définir un comportement commun pour toutes les classes
dérivées tout en laissant la possibilité de personnaliser certaines parties
ON peut maintenant créer des classes concrètes qui étendent la classe abstraite Vehicule et
implémentent la méthode abstraite demarrer. Voici un exemple simple
//Première classe concrète qui hérite de la classe abstraite Vehicule
public class Voiture extends Vehicule { //classe Concrète
private int nombrePortes;
public Voiture(String marque, int nombrePortes) {
setMarque(marque); // Methode definie dans classe abstraite Vehicule
[Link] = nombrePortes;
@Override
public void demarrer() {
[Link]("La voiture démarre.");
public int getNombrePortes() {
return nombrePortes;
public void setNombrePortes(int nombrePortes) {
[Link] = nombrePortes;
//deuxième classe concrète qui hérite de la classe abstraite Vehicule
public class Moto extends Vehicule {
private boolean BoutonDemarrage;
public Moto(String marque, boolean BoutonDemarrage) {
setMarque(marque);
[Link] = BoutonDemarrage;
@Override
public void demarrer() {
if (BoutonDemarrage) {
[Link]("La moto démarre avec un bouton.");
} else {
[Link]("La moto démarre avec un kick.");
public boolean isBoutonDemarrage() {
return BoutonDemarrage;
public void setBoutonDemarrage(boolean BoutonDemarrage) {
[Link] = BoutonDemarrage;
//Programme principale
public class Main {
public static void main(String[] args) {
Voiture voiture = new Voiture("Toyota", 4);
Moto moto = new Moto("Honda", true);
[Link]("Marque de la voiture : " + [Link]());
[Link]("Nombre de portes de la voiture : " + [Link]());
[Link]();
[Link]("\nMarque de la moto : " + [Link]());
[Link]("A bouton de démarrage de la moto : " +
[Link]());
[Link]();
2. Les Interfaces en Java
En programmation orientée objet, une interface est un contrat qui spécifie un ensemble de
méthodes publiques sans implémentation. Les classes qui implémentent une interface
doivent fournir une implémentation concrète pour toutes les méthodes définies dans
l’interface.
L’utilité des interfaces est de fournir une manière standardisée pour que différentes classes
puissent communiquer entre elles. Voici quelques avantages clés des interfaces :
1. Séparation des concepts : Les interfaces permettent de séparer la définition des
méthodes de leur implémentation, ce qui rend le code plus modulaire et flexible.
2. Polymorphisme : Grâce aux interfaces, on peut utiliser des objets de différentes classes
de manière interchangeable, tant qu’ils implémentent la même interface.
3. Facilité de maintenance : Les interfaces facilitent la maintenance et l’évolution du code
en définissant des contrats clairs entre différentes parties d’un programme.
4. Cohérence : Elles assurent une cohérence dans l’implémentation des méthodes par
différentes classes, ce qui est particulièrement utile dans les grands projets avec de
nombreux développeurs.
Continuons sur le même exemple précèdent en ajoutant des interfaces pour enrichir notre
modèle de véhicules. Nous allons définir deux interfaces : Motorisable et Confortable et
changer le code.
L’interface Motorisable définira une méthode pour démarrer le moteur, tandis que l’interface
Confortable définira des méthodes liées au confort du véhicule, comme la climatisation.
// Classe Abstraite générique
public abstract class Vehicule {
private String marque;
// Méthode concrète avec définition
public String getMarque() {
return marque;
}
public void setMarque(String marque) {
[Link] = marque;
}
}
// Interface pour les fonctionnalités du moteur
public interface Motorisable {
void demarrerMoteur();
// Interface pour les fonctionnalités de confort
public interface Confortable {
void activerClimatisation();
void desactiverClimatisation();
Maintenant, implémentons ces interfaces dans nos classes concrètes :
// La classe Voiture implémente les deux interfaces
public class Voiture extends Vehicule implements Motorisable, Confortable {
private int nombrePortes;
public Voiture(String marque, int nombrePortes) {
setMarque(marque); // Methode definie dans classe abstraite Vehicule
[Link] = nombrePortes;
// Implémentation des méthodes de l'interface Motorisable
@Override
public void demarrerMoteur() {
[Link]("Le moteur de la voiture démarre.");
// Implémentation des méthodes de l'interface Confortable
@Override
public void activerClimatisation() {
[Link]("La climatisation de la voiture est activée.");
@Override
public void desactiverClimatisation() {
[Link]("La climatisation de la voiture est désactivée.");
// La classe Moto implémente uniquement l'interface Motorisable
public class Moto extends Vehicule implements Motorisable {
// ... autres attributs et méthodes ...
// Implémentation de la méthode de l'interface Motorisable
@Override
public void demarrerMoteur() {
[Link]("Le moteur de la moto démarre.");
}....
Le code Complet est associé avec le TP sur classroom (Vihecule)