7.2.2 – Implémentation d'une interface

Pour utiliser une interface, une classe doit l'implémenter avec le mot-clé implements. La classe doit fournir une implémentation pour toutes les méthodes abstraites de l'interface.

📝 Implémentation simple

Exemple : Implémentation d'une interface

public interface Drawable {
    void draw();
    void effacer();
}

// Classe qui implémente l'interface
public class Cercle implements Drawable {
    private double rayon;
    
    public Cercle(double rayon) {
        this.rayon = rayon;
    }
    
    @Override
    public void draw() {
        System.out.println("Dessine un cercle de rayon " + rayon);
    }
    
    @Override
    public void effacer() {
        System.out.println("Efface le cercle");
    }
}

🔄 Implémentation de plusieurs interfaces

Une classe peut implémenter plusieurs interfaces, ce qui permet une grande flexibilité.

Exemple : Implémentation multiple

public interface Drawable {
    void draw();
}

public interface Colorable {
    void setColor(String color);
    String getColor();
}

public interface Resizable {
    void resize(double factor);
}

// Classe qui implémente plusieurs interfaces
public class Cercle implements Drawable, Colorable, Resizable {
    private String color;
    private double rayon;
    
    @Override
    public void draw() {
        System.out.println("Dessine un cercle " + color);
    }
    
    @Override
    public void setColor(String color) {
        this.color = color;
    }
    
    @Override
    public String getColor() {
        return color;
    }
    
    @Override
    public void resize(double factor) {
        rayon *= factor;
    }
}

💡 Utilisation polymorphique

Les interfaces permettent également l'utilisation du polymorphisme.

Exemple : Polymorphisme avec interfaces

public interface Drawable {
    void draw();
}

public class Cercle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Dessine un cercle");
    }
}

public class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Dessine un rectangle");
    }
}

// Utilisation polymorphique
public class Test {
    public static void main(String[] args) {
        Drawable[] formes = {
            new Cercle(),
            new Rectangle(),
            new Cercle()
        };
        
        for (Drawable forme : formes) {
            forme.draw();  // Polymorphisme
        }
    }
}

🆕 Méthodes par défaut et leur utilisation

Les méthodes par défaut permettent d'ajouter de nouvelles fonctionnalités aux interfaces sans casser le code existant.

Exemple : Méthodes par défaut

public interface Drawable {
    void draw();  // Méthode abstraite
    
    // Méthode par défaut : implémentation fournie
    default void afficher() {
        System.out.println("Affichage par défaut");
        draw();  // Appelle la méthode abstraite
    }
}

public class Cercle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Dessine un cercle");
    }
    
    // afficher() n'a pas besoin d'être redéfinie (utilise la version par défaut)
    // Mais peut être redéfinie si nécessaire
}

// Utilisation
Cercle c = new Cercle();
c.draw();      // Affiche : Dessine un cercle
c.afficher();  // Affiche : Affichage par défaut
               //          Dessine un cercle

📊 Exemple complet : Système de paiement

Exemple : Interface de paiement

public interface Paiement {
    // Constante
    double TAUX_TVA = 0.20;
    
    // Méthode abstraite
    void payer(double montant);
    
    // Méthode par défaut
    default double calculerAvecTVA(double montant) {
        return montant * (1 + TAUX_TVA);
    }
}

public class CarteCredit implements Paiement {
    private String numeroCarte;
    
    public CarteCredit(String numeroCarte) {
        this.numeroCarte = numeroCarte;
    }
    
    @Override
    public void payer(double montant) {
        double montantAvecTVA = calculerAvecTVA(montant);
        System.out.println("Paiement de " + montantAvecTVA + "€ par carte " + numeroCarte);
    }
}

public class Paypal implements Paiement {
    private String email;
    
    public Paypal(String email) {
        this.email = email;
    }
    
    @Override
    public void payer(double montant) {
        double montantAvecTVA = calculerAvecTVA(montant);
        System.out.println("Paiement de " + montantAvecTVA + "€ via PayPal : " + email);
    }
}

💡 Points clés à retenir

• Interface : Contrat définissant des méthodes à implémenter
• implements : Mot-clé pour implémenter une interface
• Implémentation multiple : Une classe peut implémenter plusieurs interfaces
• Méthodes abstraites : Doivent être implémentées par les classes
• Méthodes par défaut : Fournissent une implémentation par défaut (Java 8+)
• Constantes : Les interfaces peuvent contenir des constantes
• Polymorphisme : Les interfaces permettent le polymorphisme