Les classes et les objets
En Java, les classes et les objets sont des éléments fondamentaux de la
programmation orientée objet (POO). Voici une explication brève de ces
concepts avec des exemples détaillés :
Classe en Java :
Une classe est un modèle ou un plan pour créer des objets.
Elle définit les propriétés (attributs) et les comportements (méthodes) que les
objets auront.
Exemple :
public class Voiture {
// Attributs
String marque;
String modele;
int annee;
// Méthode
void demarrer() {
System.out.println("La voiture démarre.");
Objet en Java :
Un objet est une instance d'une classe.
Il est créé en utilisant le mot-clé new suivi du nom de la classe.
Exemple :
public class Exemple {
public static void main(String[] args) {
// Création d'un objet de la classe Voiture
Voiture maVoiture = new Voiture();
// Accès aux attributs et appel de méthodes
maVoiture.marque = "Toyota";
maVoiture.modele = "Camry";
maVoiture.annee = 2022;
System.out.println("Marque : " + maVoiture.marque);
System.out.println("Modèle : " + maVoiture.modele);
System.out.println("Année : " + maVoiture.annee);
maVoiture.demarrer();
Dans cet exemple, une classe Voiture est définie avec des attributs (marque,
modèle, année) et une méthode (demarrer). Ensuite, dans la classe Exemple, un
objet maVoiture est créé à partir de la classe Voiture, et ses attributs sont définis
et sa méthode est appelée.
En résumé, une classe est une abstraction qui définit la structure d'un objet, et
un objet est une instance spécifique de cette classe, possédant ses propres
valeurs d'attributs et pouvant exécuter ses propres méthodes. La POO en Java
permet d'organiser le code de manière modulaire, réutilisable et maintenable.
Les accesseurs
En Java, les accesseurs, également appelés getters et setters, sont des méthodes
permettant d'accéder et de modifier les valeurs des champs d'une classe. Ces
méthodes sont utilisées pour garantir l'encapsulation des données, en offrant un
moyen contrôlé d'accéder et de modifier les attributs d'un objet. Voici une
explication détaillée avec des exemples :
Getters (Accesseurs) :
Un getter est une méthode qui permet d'obtenir la valeur actuelle d'un attribut
d'une classe. Il a généralement la forme getType getNomAttribut ().
exemple :
public class Personne {
private String nom;
// Getter pour l'attribut "nom"
public String getNom() {
return nom;
Dans cet exemple, getNom() est le getter pour l'attribut privé nom. Il permet
d'obtenir la valeur actuelle de l'attribut nom.
Setters (Mutateurs) :
Un setter est une méthode qui permet de modifier la valeur d'un attribut d'une
classe. Il a généralement la forme void setNomAttribut(Type
nouveauNomAttribut).
exemple :
public class Personne {
private String nom;
// Setter pour l'attribut "nom"
public void setNom(String nouveauNom) {
this.nom = nouveauNom;
Dans cet exemple, setNom(String nouveauNom) est le setter pour l'attribut privé
nom. Il permet de modifier la valeur de l'attribut nom.
Utilisation dans une classe :
public class Main {
public static void main(String[] args) {
// Création d'un objet Personne
Personne personne = new Personne();
// Utilisation du setter pour définir le nom
personne.setNom("John Doe");
// Utilisation du getter pour obtenir le nom
String nomActuel = personne.getNom();
// Affichage du nom
System.out.println("Nom de la personne : " + nomActuel);
L'utilisation de getters et setters favorise l'encapsulation en fournissant un
moyen indirect d'accéder aux données d'une classe, ce qui facilite la gestion et
la modification des attributs tout en maintenant un contrôle sur leur accès.
L'héritage
L'héritage est l'un des principaux concepts de la programmation orientée objet
(POO) en Java. Il permet à une classe (appelée sous-classe ou classe dérivée)
d'hériter des propriétés et des méthodes d'une autre classe (appelée classe de
base ou superclasse). Cela favorise la réutilisation du code et permet de créer
une hiérarchie de classes.
Supposons que nous ayons une classe de base appelée "Vehicule" avec quelques
propriétés et méthodes de base :
Exemple
// Classe de base
public class Vehicule {
private String marque;
private String modele;
// Constructeur
public Vehicule(String marque, String modele) {
this.marque = marque;
this.modele = modele;
// Méthode
public void afficherDetails() {
System.out.println("Marque: " + marque);
System.out.println("Modèle: " + modele);
}
Maintenant, créons une classe dérivée appelée "Voiture" qui hérite de la classe
"Vehicule" :
Exemple
// Classe dérivée
public class Voiture extends Vehicule {
private int nombrePortes;
// Constructeur
public Voiture(String marque, String modele, int nombrePortes) {
super(marque, modele); // Appel du constructeur de la classe de base
this.nombrePortes = nombrePortes;
// Nouvelle méthode spécifique à la classe Voiture
public void afficherNombrePortes() {
System.out.println("Nombre de portes: " + nombrePortes);
Maintenant, nous pouvons utiliser ces classes dans notre programme principal :
Exemple
public class ProgrammePrincipal {
public static void main(String[] args) {
// Création d'une instance de la classe Voiture
Voiture maVoiture = new Voiture("Toyota", "Camry", 4);
// Appel de la méthode héritée de la classe de base
maVoiture.afficherDetails();
// Appel de la méthode spécifique à la classe Voiture
maVoiture.afficherNombrePortes();
Dans cet exemple, la classe "Voiture" hérite des propriétés et méthodes de la
classe "Vehicule". L'utilisation du mot-clé super permet d'appeler le
constructeur de la classe de base, et la classe dérivée peut également avoir ses
propres méthodes et propriétés spécifiques. Cela illustre le concept d'héritage
en Java.
