7.1.2 – Utilisation

Pour utiliser une classe abstraite, vous devez créer une classe fille qui hérite de la classe abstraite et implémente toutes les méthodes abstraites.

📝 Implémentation des méthodes abstraites

Les classes filles doivent fournir une implémentation pour toutes les méthodes abstraites de la classe mère.

Exemple : Implémentation complète

public abstract class Forme {
    protected String couleur;
    
    public abstract double calculerAire();
    public abstract double calculerPerimetre();
    
    public void setCouleur(String couleur) {
        this.couleur = couleur;
    }
}

// Classe Cercle : implémente toutes les méthodes abstraites
public class Cercle extends Forme {
    private double rayon;
    
    public Cercle(double rayon) {
        this.rayon = rayon;
    }
    
    @Override
    public double calculerAire() {
        return Math.PI * rayon * rayon;
    }
    
    @Override
    public double calculerPerimetre() {
        return 2 * Math.PI * rayon;
    }
}

// Classe Rectangle : implémente toutes les méthodes abstraites
public class Rectangle extends Forme {
    private double largeur;
    private double hauteur;
    
    public Rectangle(double largeur, double hauteur) {
        this.largeur = largeur;
        this.hauteur = hauteur;
    }
    
    @Override
    public double calculerAire() {
        return largeur * hauteur;
    }
    
    @Override
    public double calculerPerimetre() {
        return 2 * (largeur + hauteur);
    }
}

🚫 Instanciation impossible

Une classe abstraite ne peut pas être instanciée directement. Vous devez créer une classe fille concrète.

Exemple : Erreur d'instanciation

// ❌ ERREUR : Impossible d'instancier une classe abstraite
// Forme f = new Forme();

// ✅ CORRECT : Instancier une classe fille concrète
Forme cercle = new Cercle(5.0);
Forme rectangle = new Rectangle(4.0, 6.0);

// Utilisation polymorphique
cercle.setCouleur("Rouge");
System.out.println("Aire du cercle : " + cercle.calculerAire());

rectangle.setCouleur("Bleu");
System.out.println("Aire du rectangle : " + rectangle.calculerAire());

🔄 Utilisation polymorphique

Les classes abstraites permettent l'utilisation du polymorphisme, comme avec les classes normales.

Exemple : Polymorphisme avec classes abstraites

public class TestFormes {
    public static void main(String[] args) {
        // Tableau polymorphique
        Forme[] formes = {
            new Cercle(5.0),
            new Rectangle(4.0, 6.0),
            new Cercle(3.0)
        };
        
        // Traiter toutes les formes de manière uniforme
        for (Forme forme : formes) {
            System.out.println("Aire : " + forme.calculerAire());
            System.out.println("Périmètre : " + forme.calculerPerimetre());
            System.out.println("---");
        }
    }
}

📊 Exemple complet : Système de véhicules

Exemple : Hiérarchie de véhicules

public abstract class Vehicule {
    protected String marque;
    protected int annee;
    
    public Vehicule(String marque, int annee) {
        this.marque = marque;
        this.annee = annee;
    }
    
    // Méthode abstraite : chaque véhicule doit avoir une façon de démarrer
    public abstract void demarrer();
    
    // Méthode abstraite : chaque véhicule doit avoir une façon de s'arrêter
    public abstract void arreter();
    
    // Méthode concrète : commune à tous les véhicules
    public void afficherInfo() {
        System.out.println("Marque : " + marque + ", Année : " + annee);
    }
}

public class Voiture extends Vehicule {
    public Voiture(String marque, int annee) {
        super(marque, annee);
    }
    
    @Override
    public void demarrer() {
        System.out.println("La voiture démarre avec une clé");
    }
    
    @Override
    public void arreter() {
        System.out.println("La voiture s'arrête");
    }
}

public class Moto extends Vehicule {
    public Moto(String marque, int annee) {
        super(marque, annee);
    }
    
    @Override
    public void demarrer() {
        System.out.println("La moto démarre avec un bouton");
    }
    
    @Override
    public void arreter() {
        System.out.println("La moto s'arrête");
    }
}

💡 Points clés à retenir

• Classe abstraite : Ne peut pas être instanciée, peut contenir des méthodes abstraites et concrètes
• Méthode abstraite : Déclarée sans implémentation, doit être implémentée par les classes filles
• Implémentation obligatoire : Les classes filles non abstraites doivent implémenter toutes les méthodes abstraites
• Polymorphisme : Les classes abstraites permettent l'utilisation du polymorphisme
• Mot-clé abstract : Utilisé pour déclarer une classe ou une méthode abstraite