Java et le Café : Interfaces et Classes Abstraites

Introduction

Préparer du café en Java avec des interfaces et des classes abstraites est comme suivre des recettes flexibles et robustes. Ces concepts permettent de créer des structures de code qui favorisent la réutilisation et l’extensibilité.

Interfaces en Java

Les interfaces définissent un contrat que les classes doivent suivre, garantissant une préparation uniforme des boissons.

Définir une Interface

1
2
3
4


public interface CafeInterface {
  void servir();
  void ajouterSucre(int quantite);
}

Implémenter une Interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


public class Espresso implements CafeInterface {
  @Override
  public void servir() {
    System.out.println("Servir un Espresso.");
  }

  @Override
  public void ajouterSucre(int quantite) {
    System.out.println("Ajouter " + quantite + " sucres.");
  }

  public static void main(String[] args) {
    CafeInterface cafe = new Espresso();
    cafe.servir();
    cafe.ajouterSucre(2);
  }
}

1
2
3


$ java Espresso
Servir un Espresso.
Ajouter 2 sucres.

Classes Abstraites en Java

Les classes abstraites sont comme des recettes partiellement complétées. Elles peuvent définir certaines méthodes et laisser d’autres méthodes sans implémentation.

Définir une Classe Abstraite

1
2
3
4
5
6
7


public abstract class CafeAbstrait {
  public abstract void servir();

  public void ajouterLait() {
    System.out.println("Ajouter du lait.");
  }
}

Étendre une Classe Abstraite

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


public class Cappuccino extends CafeAbstrait {
  @Override
  public void servir() {
    System.out.println("Servir un Cappuccino.");
  }

  public static void main(String[] args) {
    CafeAbstrait cafe = new Cappuccino();
    cafe.servir();
    cafe.ajouterLait();
  }
}

1
2
3


$ java Cappuccino
Servir un Cappuccino.
Ajouter du lait.

Conclusion

Les interfaces et les classes abstraites en Java vous permettent de créer des structures de code flexibles et robustes. Comme des recettes de café bien conçues, elles favorisent la réutilisation et l’extensibilité du code. Utilisez ces concepts pour préparer des boissons délicieuses avec moins d’effort et plus de cohérence.

← Polymorphisme | Exceptions personnalisées →