Abstraction : classe abstraite vs interface

Lors de la conception de logiciels en Java, le choix entre les classes abstraites et les interfaces peut avoir un impact important sur la flexibilité, la maintenabilité et la lisibilité. Dans cet article, nous explorerons leurs principales différences, quand les utiliser l'un par rapport à l'autre, et examinerons des exemples pratiques pour vous aider à maîtriser ce concept.

---

Différences clés entre la classe abstraite et l'interface

Fonctionnalité Cours abstrait Interface ête>

Feature	Abstract Class	Interface
Purpose	Achieves partial implementation	Achieves complete abstraction
Method Implementations	Can have both abstract and concrete methods	All methods are abstract (except default/static methods in Java 8 )
Multiple Inheritance	A class can extend only one abstract class	A class can implement multiple interfaces
Fields/Variables	Can have instance variables of any type	All variables are implicitly public, static, and final
Constructors	Can have constructors	Cannot have constructors
Inheritance Support	Can implement multiple interfaces	Cannot extend an abstract class
Use Case	Useful for sharing common code and state	Useful for defining a contract across unrelated classes

Objectif Réalise une mise en œuvre partielle Obtient une abstraction complète Implémentations de méthodes Peut avoir à la fois des méthodes abstraites et concrètes Toutes les méthodes sont abstraites (sauf les méthodes par défaut/statiques dans Java 8) Héritage multiple Une classe ne peut étendre qu'une seule classe abstraite Une classe peut implémenter plusieurs interfaces Champs/Variables Peut avoir des variables d'instance de n'importe quel type Toutes les variables sont implicitement publiques, statiques et finales Constructeurs Peut avoir des constructeurs Impossible d'avoir des constructeurs Aide à l'héritage Peut implémenter plusieurs interfaces Impossible d'étendre une classe abstraite Cas d'utilisation Utile pour partager code et état communs Utile pour définir un contrat entre des classes non liées

---

Quand utiliser une classe abstraite ou une interface ?

Utilisez la Classe abstraite Lorsque :

• Vous devez partager votre état ou votre comportement entre les classes associées.
  
  Exemple : L'employé peut avoir des champs comme le nom et l'identifiant avec une méthode getDetails() commune, partagée entre ses sous-classes Manager et Lead.
  

  abstract class Employee {
      String name;
      int id;
  
      Employee(String name, int id) {
          this.name = name;
          this.id = id;
      }
  
      // Concrete method shared among subclasses
      public void getDetails() {
          System.out.println(name + " (ID: " + id + ")");
      }
  
      // Abstract method to be implemented by subclasses
      abstract double getSalary();
  }
  
  class Manager extends Employee {
      Manager(String name, int id) {
          super(name, id);
      }
  
      @Override
      double getSalary() {
          return 75000;
      }
  }
  

• Vous souhaitez définir des champs et constructeurs que les sous-classes peuvent utiliser.

• Vous devez fournir des implémentations partielles ou des méthodes utilitaires pour les sous-classes.

Utiliser l'Interface Lorsque :

• Vous souhaitez définir un comportement commun entre classes non liées.
  
  Exemple : Car et Drone pourraient implémenter une interface Operable, car ils partagent tous deux une méthode start() mais sont des classes non liées.
  

  interface Operable {
      void start();
      void stop();
  }
  
  class Car implements Operable {
      @Override
      public void start() {
          System.out.println("Car started.");
      }
  
      @Override
      public void stop() {
          System.out.println("Car stopped.");
      }
  }
  
  class Drone implements Operable {
      @Override
      public void start() {
          System.out.println("Drone started.");
      }
  
      @Override
      public void stop() {
          System.out.println("Drone stopped.");
      }
  }
  

• Vous avez besoin d'un héritage multiple pour combiner différents comportements. Par exemple, une classe peut implémenter à la fois Runnable et Serialisable.

• Vous souhaitez définir des méthodes par défaut pour ajouter de nouvelles fonctionnalités sans rompre la compatibilité ascendante.

---

Résumés des entretiens

Questions d'entretien courantes :

1. Pourquoi une interface ne peut-elle pas avoir de constructeurs ?
   
   Puisque les interfaces définissent des abstractions pures, il n'y a pas besoin de constructeurs. Seules les classes abstraites, qui contiennent une certaine implémentation, nécessitent que les constructeurs initialisent l'état.

2. Pourquoi utiliser des classes abstraites plutôt que des interfaces ?
   
   Utilisez des classes abstraites lorsque :

   • Vous devez partager le code entre les classes associées.
   • Vous souhaitez définir un état (champs) et des constructeurs.

3. Une classe abstraite peut-elle implémenter une interface ?
   
   Oui! Les classes abstraites peuvent implémenter une ou plusieurs interfaces. Ils peuvent même fournir des implémentations par défaut pour les méthodes d'interface.

4. Pouvez-vous utiliser à la fois des classes abstraites et des interfaces dans la même classe ?
   
   Oui, une classe peut étendre une classe abstraite et implémenter plusieurs interfaces. Cela permet des modèles de conception flexibles et un héritage multiple.

---

Résumé

• Les Classes abstraites sont idéales lorsque vous avez besoin d'une implémentation partielle et d'un état partagé entre les classes associées. Ils autorisent des champs, des constructeurs et des méthodes utilitaires communs.
• Les Interfaces sont les mieux adaptées à l'abstraction complète, à l'héritage multiple et à la définition d'un comportement commun pour des classes non liées. Ils vous permettent de faire évoluer votre base de code avec les méthodes par défaut tout en conservant une compatibilité ascendante.

En maîtrisant les différences et en sachant quand les utiliser, vous serez mieux équipé pour concevoir des systèmes logiciels évolutifs et maintenables.

---

Articles connexes

• Principes fondamentaux de Java

• Les essentiels de l'entretien avec Array

• L'essentiel de la mémoire Java

• L'essentiel des mots-clés Java

• L'essentiel du cadre de collections

Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!