Interfaces et classes abstraites en Java

Les interfaces et les classes abstraites sont les composants essentiels pour réaliser l'abstraction et le polymorphisme.

Que sont les interfaces ?

Une interface en Java est un type de référence, similaire à une classe, qui ne peut contenir que des méthodes abstraites, des méthodes statiques, des méthodes par défaut et des variables finales statiques (constantes). Les interfaces sont utilisées pour réaliser l'abstraction et l'héritage multiple en Java. Les interfaces ne peuvent pas être directement instanciées.

?Avant Java 8, les interfaces ne pouvaient avoir que des méthodes abstraites.
La mise en œuvre de ces méthodes doit être assurée dans une classe distincte. Ainsi, si une nouvelle méthode doit être ajoutée dans une interface, alors son code d'implémentation doit être fourni dans la classe implémentant la même interface.

?Pour pallier ce problème, Java 8 a introduit le concept de méthodes par défaut qui permettent aux interfaces d'avoir des méthodes avec implémentation sans affecter les classes qui implémentent l'interface .

Les méthodes par défaut peuvent être remplacées en implémentant des classes si nécessaire.

Principales caractéristiques des interfaces

• Méthodes abstraites : Méthodes sans corps, déclarées à l'aide du mot-clé abstract.
• Méthodes par défaut : Méthodes avec un corps, introduites dans Java 8, permettant aux interfaces de fournir des implémentations par défaut.
• Méthodes statiques : méthodes qui appartiennent à l'interface elle-même, et non aux instances de l'interface.
• Constantes : Variables déclarées comme statiques et finales, qui sont implicitement publiques.

Que sont les classes abstraites ?

Une classe abstraite en Java est une classe qui ne peut pas être instanciée seule et peut contenir des méthodes abstraites (méthodes sans corps) et des méthodes concrètes (méthodes avec corps). Les classes abstraites sont utilisées pour fournir une base commune aux sous-classes, permettant la réutilisation du code et la définition d'un comportement partagé.

Principales caractéristiques des classes abstraites

• Méthodes abstraites : Méthodes sans corps, déclarées à l'aide du mot-clé abstract.
• Méthodes concrètes : méthodes avec un corps, fournissant des implémentations par défaut.
• Constructeurs : les classes abstraites peuvent avoir des constructeurs, mais elles ne peuvent pas être instanciées directement.
• Variables d'instance : les classes abstraites peuvent avoir des variables d'instance et des variables statiques.

Différences entre les interfaces et les classes abstraites

Héritage multiple

• Interfaces : Java prend en charge l'héritage multiple via des interfaces, permettant à une classe d'implémenter plusieurs interfaces.
• Classes abstraites : Java ne prend pas en charge l'héritage multiple de classes, ce qui signifie qu'une classe ne peut étendre qu'une seule classe abstraite.

Corps de méthode

• Interfaces : Avant Java 8, les interfaces ne pouvaient pas contenir de corps de méthode. Avec Java 8, les méthodes par défaut et statiques peuvent avoir des corps.
• Classes abstraites : Les classes abstraites peuvent contenir à la fois des méthodes abstraites (sans corps) et des méthodes concrètes (avec corps).

Variables

• Interfaces : les variables dans les interfaces sont implicitement publiques, statiques et finales.
• Classes abstraites : les classes abstraites peuvent avoir des variables d'instance, des variables statiques et des constantes.

Usage

• Interfaces : Idéales pour définir des contrats que plusieurs classes peuvent mettre en œuvre.
• Classes abstraites : Convient pour fournir une base commune à une famille de classes liées, partageant du code et du comportement.

L'approche Java de l'héritage

Java ne prend en charge qu'un seul héritage, ce qui signifie que chaque classe peut hériter des champs et des méthodes d'une seule classe. Si vous devez hériter de propriétés de plusieurs sources, Java fournit le concept d'interfaces, qui est une forme d'héritage multiple.

?Les interfaces sont similaires aux classes. Cependant, ils définissent uniquement la signature des méthodes et non leurs implémentations. Les méthodes déclarées dans l'interface sont implémentées dans les classes. L'L'héritage multiple se produit lorsqu'une classe implémente plusieurs interfaces.

En Java, l'héritage multiple est réalisé via des interfaces plutôt que des classes. Cela permet à une classe d'implémenter plusieurs interfaces, héritant des signatures de méthode de chacune d'elles. Vous trouverez ci-dessous un exemple illustrant l'héritage multiple à l'aide d'interfaces.

Exemple d'héritage multiple à l'aide d'interfaces

Définissons deux interfaces, Flyable et Swimmable, et une classe Duck qui implémente les deux interfaces.

Interface : Pilotable

public interface Flyable {
    void fly();
}

Interface : Baignable

public interface Swimmable {
    void swim();
}

Classe : Canard

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

Explication

1. Interfaces :

   • L'interface Flyable définit une méthode fly().
   • L'interface Swimmable définit une méthode swim().

2. Classe :

   • La classe Duck implémente les interfaces Flyable et Swimmable.
   • La classe Duck fournit des implémentations pour les méthodes fly() et swim().

3. Méthode principale :

   • Une instance de Duck est créée.
   • Les méthodes fly() et swim() sont appelées sur l'instance Duck, démontrant que la classe Duck a hérité du comportement des deux interfaces.

Sortir

Duck is flying
Duck is swimming

Voici un schéma simple pour illustrer la relation :

+----------------+
|    Flyable     |Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |Interface
|----------------|
| + swim()       |
+----------------+

Dans cet exemple, la classe Duck démontre l'héritage multiple en implémentant les interfaces Flyable et Swimmable. Cela permet à la classe Duck d'hériter et de fournir des implémentations pour les méthodes définies dans les deux interfaces, montrant comment Java réalise un héritage multiple via les interfaces.

---

Classe abstraite en Java

Les classes abstraites en Java sont utilisées pour fournir une base commune à une famille de classes liées. Ils peuvent contenir à la fois des méthodes abstraites (méthodes sans corps) et des méthodes concrètes (méthodes avec corps). Vous trouverez ci-dessous un exemple illustrant l'utilisation d'une classe abstraite.

Exemple de classe abstraite

Définissons une classe abstraite Animal et deux sous-classes Dog et Cat qui étendent la classe Animal.

Classe abstraite : Animal

public abstract class Animal {
    // Abstract method (does not have a body)
    public abstract void makeSound();

    // Concrete method (has a body)
    public void sleep() {
        System.out.println("The animal is sleeping");
    }
}

Sous-classe : Chien

public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog says: Woof!");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

Sous-classe : Chat

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat says: Meow!");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();
        cat.sleep();
    }
}

Explication

1. Classe abstraite : Animal

   • La classe Animal est déclarée comme abstraite, ce qui signifie qu'elle ne peut pas être instanciée directement.
   • Il contient une méthode abstraite makeSound(), qui doit être implémentée par n'importe quelle sous-classe.
   • Il contient également une méthode concrète sleep(), qui fournit une implémentation par défaut.

2. Sous-classe : Chien

   • La classe Chien étend la classe Animal.
   • Il fournit une implémentation pour la méthode abstraite makeSound().
   • La méthode main crée une instance de Dog et appelle les méthodes makeSound() et sleep().

3. Sous-classe : Chat

   • La classe Cat étend la classe Animal.
   • Il fournit une implémentation pour la méthode abstraite makeSound().
   • La méthode main crée une instance de Cat et appelle les méthodes makeSound() et sleep().

Sortir

Pour la classe Chien :

public interface Flyable {
    void fly();
}

Pour la classe Chat :

public interface Swimmable {
    void swim();
}

Voici un schéma simple pour illustrer la relation :

public class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }

    public static void main(String[] args) {
        Duck duck = new Duck();
        duck.fly();
        duck.swim();
    }
}

Dans cet exemple, la classe abstraite Animal fournit une base commune pour les sous-classes Dog et Cat. La classe Animal définit une méthode abstraite makeSound() qui doit être implémentée par n'importe quelle sous-classe, et une méthode concrète sleep() qui fournit une implémentation par défaut. Les classes Dog et Cat étendent la classe Animal et fournissent leurs propres implémentations de la méthode makeSound().

Points clés sur les interfaces

1. Abstraction : L'interface en Java est un mécanisme permettant de réaliser l'abstraction.
2. Méthodes par défaut : Par défaut, les méthodes d'interface sont abstraites et publiques.
3. Types de méthodes : les méthodes d'interface ne peuvent être que publiques, privées, abstraites, par défaut, statiques et strictfp.
4. Types de champs : les champs d'interface (variables) peuvent être uniquement publics, statiques ou finaux.
5. Relation IS-A : L'interface Java représente également la relation IS-A.
6. Instanciation : Elle ne peut pas être directement instanciée, tout comme la classe abstraite.
7. Couplage lâche : Il peut être utilisé pour obtenir un couplage lâche.
8. Implicitement abstrait : chaque interface est implicitement abstraite.
9. Méthodes par défaut : les méthodes par défaut ne sont autorisées que dans les interfaces.

Duck is flying
Duck is swimming

Applications pratiques

Utilisation des interfaces

Les interfaces sont couramment utilisées pour définir des API, des frameworks et des bibliothèques. Par exemple, l'interface java.util.List fournit un contrat pour les implémentations de listes, telles que ArrayList et LinkedList.

+----------------+
|    Flyable     |Interface
|----------------|
| + fly()        |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|     Duck       |Class
|----------------|
| + fly()        |
| + swim()       |
+----------------+
          ^
          |
          | Implements
          |
+----------------+
|   Swimmable    |Interface
|----------------|
| + swim()       |
+----------------+

Utiliser des classes abstraites

Les classes abstraites sont souvent utilisées pour fournir une classe de base à une famille de classes apparentées. Par exemple, la classe java.util.AbstractList fournit une implémentation squelettique de l'interface List, réduisant ainsi la quantité de code que les sous-classes doivent implémenter.

public interface Flyable {
    void fly();
}

---

Différence entre l'interface et la classe abstraite

SNo	Interface	Abstract Class
1	Interfaces cannot be instantiated	Abstract classes cannot be instantiated
2	It can have both abstract and non-abstract methods	It can have both abstract and non-abstract methods
3	In interfaces, all fields are automatically public, static, and final, and all methods that you declare or define (as default methods) are public	In abstract classes, you can declare fields that are not static and final, and define public, protected, and private concrete methods
4	Interface supports multiple inheritance. Multiple interfaces can be implemented	Abstract class or class can extend only one class
5	It is used if you expect that unrelated classes would implement your interface. Eg, the interfaces Comparable and Cloneable are implemented by many unrelated classes	It is used if you want to share code among several closely related classes
6	It is used if you want to specify the behavior of a particular data type, but not concerned about who implements its behavior.	It is used if you expect that classes that extend your abstract class have many common methods or fields, or require access modifiers other than public (such as protected and private)

Réf : https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
Lorsqu'une classe abstraite est sous-classée, la sous-classe fournit généralement des implémentations pour toutes les méthodes abstraites de sa classe parent. Cependant, si ce n'est pas le cas, la sous-classe doit également être déclarée abstraite.

---

Avis d'experts

Selon Joshua Bloch, auteur de "Effective Java", les interfaces sont préférées aux classes abstraites pour définir des types car elles sont plus flexibles et prennent en charge l'héritage multiple. Cependant, les classes abstraites sont utiles pour fournir des fonctionnalités partagées et réduire la duplication de code.

"Les interfaces sont idéales pour définir des mixins. Les classes, en revanche, sont idéales pour définir des objets qui ont des propriétés intrinsèques."

• Josué Bloch

Points forts

• Interfaces : Idéales pour définir des contrats et prendre en charge les héritages multiples.
• Classes abstraites : convient pour fournir une base commune pour les classes associées, partager du code et des comportements.
• Différences : les interfaces ne peuvent avoir que des méthodes abstraites (avant Java 8), tandis que les classes abstraites peuvent avoir à la fois des méthodes abstraites et concrètes.
• Utilisation : les interfaces sont utilisées pour définir des API et des frameworks, tandis que les classes abstraites sont utilisées pour fournir des implémentations squelettiques.

Explorer plus loin

Explorez la puissance des interfaces et des classes abstraites dans vos propres projets Java. Expérimentez en définissant des contrats à l'aide d'interfaces et en fournissant des fonctionnalités partagées à l'aide de classes abstraites. Partagez vos idées et expériences avec la communauté Java pour contribuer à la connaissance et à la croissance collectives.

Toutes corrections ou ajouts à cet article sont les bienvenus.

public interface Flyable {
    void fly();
}

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!