Objets et classes en Java

Classes et objets en Java

  Prérequis

Maîtriser les types primitifs, les variables et la structure d'un programme Java. Avoir des notions de base sur la programmation procédurale.

  Objectifs

Comprendre les concepts fondamentaux de la programmation orientée objet en Java : définir une classe, déclarer des attributs et des méthodes, créer des objets avec des constructeurs, et accéder aux membres via l'opérateur point.

  Un peu d'histoire

La Programmation Orientée Objet (POO) est née dans les années 1960 avec le langage Simula. Elle a été popularisée par Smalltalk (1972) puis adoptée massivement par C++, Java et Python. Java a été conçu dès 1995 comme un langage entièrement orienté objet : tout code Java (hors types primitifs) est encapsulé dans des classes.

1. Les piliers de la POO en Java

2. La classe — modèle de l'objet

2.1 Syntaxe de déclaration

class NomDeLaClasse {

    // ── Attributs (variables d'instance) ──
    typeAttribut nomAttribut;

    // ── Constructeur ──
    NomDeLaClasse() {
        // initialisation
    }

    // ── Méthodes ──
    typeRetour nomMethode() {
        // instructions
    }
}

  Exemple 1 — Classe Lampe

class Lampe {

    // Attribut (variable d'instance)
    private boolean isOn;

    // Méthode — allumer la lampe
    public void allumer() {
        isOn = true;
    }

    // Méthode — éteindre la lampe
    public void eteindre() {
        isOn = false;
    }
}

2.2 Les trois types de variables dans une classe

  Exemple 2 — Les trois types de variables

class Compteur {

    // Variable de classe (partagée par tous les objets)
    static int nombreInstances = 0;

    // Variable d'instance (propre à chaque objet)
    private int valeur;

    public void incrementer() {
        // Variable locale (existe seulement dans cette méthode)
        int pas = 1;
        valeur += pas;
    }
}

2.3 Les modificateurs d'accès

3. Les constructeurs

  Exemple 3 — Constructeurs et mot-clé this

class Lampe {

    private boolean isOn;

    // Constructeur par défaut — lampe éteinte
    public Lampe() {
        this.isOn = false;
        System.out.println("Constructeur par défaut appelé");
    }

    // Constructeur d'initialisation — état défini par le paramètre
    public Lampe(boolean etat) {
        this.isOn = etat;
        System.out.println("Constructeur d'initialisation appelé");
    }

    public static void main(String[] args) {
        Lampe l1 = new Lampe();        // appelle le 1er constructeur
        Lampe l2 = new Lampe(true);    // appelle le 2nd constructeur
    }
}

Constructeur par défaut appelé
Constructeur d'initialisation appelé

4. Les objets en Java

4.1 Les trois étapes de création d'un objet

// Les trois étapes en une ligne
NomClasse nomObjet = new NomClasse(argumentsConstructeur);

4.2 Accès aux membres via l'opérateur point

  Exemple 4 — Création et utilisation d'objets

class Lampe {

    private boolean isOn;

    public Lampe() {
        this.isOn = false;
    }

    public void allumer() {
        isOn = true;
        System.out.println("Lampe allumée");
    }

    public void eteindre() {
        isOn = false;
        System.out.println("Lampe éteinte");
    }

    public boolean getEtat() {
        return isOn;
    }

    public static void main(String[] args) {
        // Création de deux objets distincts
        Lampe l1 = new Lampe();
        Lampe l2 = new Lampe();

        // Chaque objet a son propre état
        l1.allumer();
        System.out.println("l1 allumée ? " + l1.getEtat()); // true
        System.out.println("l2 allumée ? " + l2.getEtat()); // false

        l1.eteindre();
    }
}

Lampe allumée
l1 allumée ? true
l2 allumée ? false
Lampe éteinte

5. Packages et instructions d'importation

// Importer une classe spécifique
import java.util.ArrayList;

// Importer toutes les classes d'un package
import java.io.*;

// Structure complète d'un fichier source
package ma.mp.cpge;          // 1. déclaration du package

import java.util.ArrayList;    // 2. imports

public class Etudiant {        // 3. déclaration de la classe
    // ...
}

  Exemple 5 — Structure complète d'un fichier source

// 1. Package
package ma.mp.cpge.poo;

// 2. Imports
import java.util.ArrayList;
import java.util.List;

// 3. Classe publique (nom = nom du fichier : Ecole.java)
public class Ecole {

    // Variable de classe
    private static String nom = "MP";

    // Variable d'instance
    private List<String> etudiants;

    // Constructeur
    public Ecole() {
        this.etudiants = new ArrayList<>();
    }

    // Méthode
    public void ajouterEtudiant(String prenom) {
        etudiants.add(prenom);
        System.out.println(prenom + " ajouté(e) à " + nom);
    }

    public static void main(String[] args) {
        Ecole e = new Ecole();
        e.ajouterEtudiant("Mostafa");
        e.ajouterEtudiant("Sara");
    }
}

Mostafa ajouté(e) à MP
Sara ajouté(e) à MP

6. Exercice

=== Compte de Mostafa ===
Numéro : 23123123123
Solde  : 1500.0 MAD
Dépôt de 500.0 MAD effectué.
Retrait de 200.0 MAD effectué.
Solde insuffisant pour retirer 2000.0 MAD.
=== Compte de Mostafa ===
Numéro : 23123123123
Solde  : 1800.0 MAD

public class CompteBancaire {

    // ── Attributs privés ──────────────────────────────────
    private String titulaire;
    private String numero;
    private double solde;

    // ── Constructeur ──────────────────────────────────────
    public CompteBancaire(String titulaire, String numero, double soldeInitial) {
        this.titulaire = titulaire;
        this.numero    = numero;
        this.solde     = soldeInitial;
    }

    // ── Méthodes ──────────────────────────────────────────
    public void deposer(double montant) {
        if (montant <= 0) {
            System.out.println("Montant invalide pour un dépôt.");
            return;
        }
        solde += montant;
        System.out.println("Dépôt de " + montant + " MAD effectué.");
    }

    public void retirer(double montant) {
        if (montant > solde) {
            System.out.println("Solde insuffisant pour retirer " + montant + " MAD.");
            return;
        }
        solde -= montant;
        System.out.println("Retrait de " + montant + " MAD effectué.");
    }

    public void afficherEtat() {
        System.out.println("=== Compte de " + titulaire + " ===");
        System.out.println("Numéro : " + numero);
        System.out.println("Solde  : " + solde + " MAD");
    }

    // ── Programme principal ───────────────────────────────
    public static void main(String[] args) {
        CompteBancaire c1 = new CompteBancaire("Mostafa", "FR7612345", 1500.0);

        c1.afficherEtat();
        c1.deposer(500.0);
        c1.retirer(200.0);
        c1.retirer(2000.0);  // refusé — solde insuffisant
        c1.afficherEtat();
    }
}

=== Compte de Mostafa ===
Numéro : FR7612345
Solde  : 1500.0 MAD
Dépôt de 500.0 MAD effectué.
Retrait de 200.0 MAD effectué.
Solde insuffisant pour retirer 2000.0 MAD.
=== Compte de Mostafa ===
Numéro : FR7612345
Solde  : 1800.0 MAD

  L'essentiel en bref

En Java, une classe est un modèle regroupant des attributs (état) et des méthodes (comportements). Un objet est une instance de classe créée avec new, possédant son propre état indépendant. Le constructeur — portant le nom de la classe — initialise l'objet à la création ; une classe peut en avoir plusieurs (surcharge). L'accès aux membres se fait via l'opérateur point (.). Les attributs sont généralement déclarés private (encapsulation) et les méthodes public. Les packages organisent les classes en namespaces, et les imports permettent d'utiliser des classes externes sans écrire leur chemin complet.