Aller au contenu

Synthèse des concepts POO

concepts POO

Classe

Définition : Une classe est un modèle ou un plan qui définit les propriétés (attributs) et les comportements (méthodes) communs à un ensemble d’objets. C’est un concept logique (pas physique).

public class Voiture {
    // Attributs (propriétés)
    private String marque;
    private double prix;
    private int vitesseMax;

    // Méthodes (comportements)
    public void demarrer() { /* ... */ }
    public void freiner() { /* ... */ }
}

Analogie : Une classe est comme un moule à gâteau : elle définit la forme (attributs) et les instructions (méthodes), mais ce n’est pas un gâteau (objet) en soi. Exemples de classes : Voiture, Etudiant, CompteBancaire.

Objet

Définition : Un objet est une instance concrète d’une classe. Il possède un état (valeurs des attributs) et un comportement (méthodes).

Voiture maVoiture = new Voiture();  // maVoiture est un objet de la classe Voiture
maVoiture.marque = "Toyota";
maVoiture.prix = 25000.0;

Analogie : Si la classe est un moule à gâteau, l’objet est un gâteau spécifique (gâteau au chocolat ou à la vanille). Exemples d’objets : maVoiture, monCompte, etudiant123, gâteauAuChocolat…

Héritage

Définition : L’héritage permet à une classe (classe enfant) d’hériter des attributs et méthodes d’une autre classe (classe parent). Cela crée une relation hiérarchique (“est un”).

public class VoitureElectrique extends Voiture {
    private int autonomie;  // Attribut spécifique

    public void recharger() { /* ... */ }  // Méthode spécifique
}

Analogie : Comme une filiation : une VoitureElectrique est une Voiture (elle hérite de ses caractéristiques) mais avec des spécificités (autonomie). Les avantages sont la réutilisation du code (évite la duplication) et polymorphisme (voir plus bas).

Polymorphisme

Définition : Le polymorphisme permet à une méthode ou un objet de prendre plusieurs formes. Deux types :

Exemple 1 (Surcharge) :

public class Voiture {
    public void demarrer() { /* ... */ }
    public void demarrer(boolean modeSilencieux) { /* ... */ }  // Surcharge
}

Exemple 2 (Redéfinition) :

public class VoitureElectrique extends Voiture {
    @Override
    public void demarrer() {
        System.out.println("Démarrage silencieux...");
    }
}

Analogie : Comme le verbe “courir” :

Le sens dépend du contexte (ici, la classe ou les paramètres).

Abstraction

Définition : L’abstraction consiste à masquer les détails complexes et à ne montrer que les fonctionnalités essentielles à l’utilisateur. Elle permet de créer des modèles simplifiés.

public abstract class Vehicule {
    public abstract void demarrer();  // méthode abstraite (sans implémentation)
}

public class Voiture extends Vehicule {
    @Override
    public void demarrer() {
        System.out.println("Démarrage avec clé...");
    }
}

Analogie dans la conduite d’une voiture :

Encapsulation

Définition : L’encapsulation consiste à cacher les données (attributs) d’une classe et à n’autoriser l’accès qu’à travers des méthodes publiques (getters/setters). Cela protège l’intégrité des données.

public class CompteBancaire {
    private double solde;  // attribut privé

    // méthode publique pour accéder au solde
    public double getSolde() {
        return solde;
    }

    // méthode publique pour modifier le solde (avec validation)
    public void setSolde(double solde) {
        if (solde >= 0) {
            this.solde = solde;
        }
    }
}

Analogie : Comme une capsule médicinale.

Association

Définition : L’association est une relation bidirectionnelle ou unidirectionnelle entre deux objets, où chaque objet a son propre cycle de vie. Aucun objet ne “possède” l’autre !

public class Enseignant {
    private List<Etudiant> etudiants;  // un enseignant a plusieurs étudiants
}

public class Etudiant {
    private List<Enseignant> enseignants;  // un étudiant a plusieurs enseignants
}

Analogie : Relation entre un professeur et ses élèves.

Agrégation

Définition : L’agrégation est une forme d’association où un objet (le “tout”) contient d’autres objets (les “parties”), mais les parties peuvent exister indépendamment du tout.

public class Departement {
    private List<Enseignant> enseignants;  // Un département AGRÈGE des enseignants
}

Analogie : Département universitaire et ses enseignants ou entreprise et salariés

Composition

Définition : La composition est une forme forte d’aggrégation où les parties n’existent pas sans le tout. Si le tout est détruit, les parties le sont aussi.

public class Maison {
    private List<Piece> pieces;  // Une maison EST COMPOSÉE de pièces

    public Maison() {
        this.pieces = new ArrayList<>();
        pieces.add(new Piece("Cuisine")); // instancié au sein de l'objet
        pieces.add(new Piece("Salon")); // idem
    }
}

public class Piece {
    private String nom;

    public Piece(String nom) {
        this.nom = nom;
    }
}

Analogie : Maison et ses pièces, corps humain et ses organes

Avantages de la POO

Avantage Description Exemple
Modularité Le code est organisé en modules indépendants (classes). Une classe Voiture peut être réutilisée dans différents programmes.
Réutilisabilité Les classes et objets peuvent être réutilisés (via héritage, composition, etc.). Une classe Vehicule peut être étendue par Voiture ou Moto.
Maintenabilité Facile à mettre à jour (changements localisés dans les classes). Modifier la classe CompteBancaire n’affecte pas les autres classes.
Extensibilité Ajouter de nouvelles fonctionnalités sans casser le code existant. Ajouter une méthode recharger() à VoitureElectrique sans toucher à Voiture.
Sécurité L’encapsulation protège les données contre les accès non autorisés. Un solde privé ne peut être modifié que via setSolde().

Concepts de la POO

Concept Définition Exemple
Classe Modèle définissant les attributs et méthodes d’un ensemble d’objets. class Voiture { ... }
Objet Instance concrète d’une classe. Voiture maVoiture = new Voiture();
Héritage Une classe hérite des attributs/méthodes d’une autre classe. class VoitureElectrique extends Voiture { ... }
Polymorphisme Une méthode/objet peut prendre plusieurs formes. Surcharge (demarrer() et demarrer(boolean)) ou redéfinition (@Override).
Abstraction Masquer les détails complexes et exposer seulement l’essentiel. abstract class Vehicule { abstract void demarrer(); }
Encapsulation Protéger les données en les rendant privées et en fournissant des méthodes publiques. private double solde; public double getSolde() { ... }
Association Relation entre objets sans dépendance forte. Un Enseignant peut être associé à plusieurs Etudiant (et vice versa).
Agrégation Un objet contient d’autres objets, mais ces objets peuvent exister indépendamment. Un Departement agrège des Enseignant (les enseignants existent sans le département).
Composition Un objet contient d’autres objets qui n’existent pas sans lui. Une Maison est composée de Piece (une pièce n’existe pas sans la maison).

Exercice Pratique

Énoncé :

Solution :

// Classe abstraite Animal
public abstract class Animal {
    private String nom;  // Encapsulation

    public Animal(String nom) {
        this.nom = nom;
    }

    public abstract void faireDuBruit();  // Abstraction + Polymorphisme

    public String getNom() {  // Encapsulation
        return nom;
    }
}

// Sous-classe Chien
public class Chien extends Animal {
    public Chien(String nom) {
        super(nom);
    }

    @Override
    public void faireDuBruit() {
        System.out.println(getNom() + " dit: Woof!");
    }
}

// Sous-classe Chat
public class Chat extends Animal {
    public Chat(String nom) {
        super(nom);
    }

    @Override
    public void faireDuBruit() {
        System.out.println(getNom() + " dit: Miaou!");
    }
}

// Classe Main
public class Main {
    public static void main(String[] args) {
        List<Animal> animaux = new ArrayList<>();
        animaux.add(new Chien("Rex"));
        animaux.add(new Chat("Mistigri"));

        for (Animal animal : animaux) {
            animal.faireDuBruit();  // Polymorphisme : appelle la bonne méthode
        }
    }
}

Concepts illustrés :