implémente le mot-clé en Java

Le mot-clé implements en Java est utilisé pour indiquer qu'une classe va implémenter une interface. En utilisant implements, une classe accepte de fournir des implémentations concrètes pour toutes les méthodes abstraites déclarées dans l'interface.

Utilisation

Le mot-clé implements est utilisé dans une déclaration de classe pour spécifier une ou plusieurs interfaces que la classe implémentera.

Syntax

class ClassName implements InterfaceName {
    // Class body with implementations of interface methods
}

• ClassName: Le nom de la classe qui implémente l'interface.
• InterfaceName: Le nom de l'interface en cours d'implémentation. Plusieurs interfaces peuvent être mises en œuvre en les séparant par des virgules.

Exemples

Exemple 1 : Mise en œuvre d'une interface unique

interface Animal {
    void makeSound();
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Bark");
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();  // Outputs: Bark
    }
}

Dans cet exemple, la classe Dog met en œuvre l'interface Animal. La méthode makeSound est définie dans la classe Dog pour fournir le comportement spécifique d'un chien.

Exemple 2 : Mise en œuvre d'interfaces multiples

interface Animal {
    void makeSound();
}

interface Pet {
    void play();
}

public class Cat implements Animal, Pet {
    public void makeSound() {
        System.out.println("Meow");
    }

    public void play() {
        System.out.println("Playing with a ball of yarn");
    }

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();  // Outputs: Meow
        cat.play();       // Outputs: Playing with a ball of yarn
    }
}

Ici, la classe Cat met en œuvre deux interfaces, Animal et Pet. Il fournit des implémentations concrètes pour les méthodes makeSound et play.

Exemple 3 : Mise en œuvre d'une interface avec des méthodes par défaut

interface Vehicle {
    void start();
    default void stop() {
        System.out.println("Vehicle stopped");
    }
}

public class Car implements Vehicle {
    public void start() {
        System.out.println("Car started");
    }

    public static void main(String[] args) {
        Car car = new Car();
        car.start();  // Outputs: Car started
        car.stop();   // Outputs: Vehicle stopped
    }
}

Dans cet exemple, l'interface Vehicle a une méthode par défaut stop. La classe Car implémente l'interface Vehicle et fournit une implémentation de la méthode start. La méthode par défaut de stop est héritée par la classe Car.

Conseils et bonnes pratiques

• Séparation des interfaces: Implémenter des interfaces spécifiques à la fonctionnalité de la classe. Cela permet de respecter le principe de séparation des interfaces (ISP), ce qui rend le code plus modulaire et plus facile à maintenir.
• Héritage multiple: Utiliser les interfaces pour réaliser l'héritage multiple en Java. Une classe peut mettre en œuvre plusieurs interfaces, ce qui lui permet d'hériter du comportement de plusieurs sources.
• Méthodes par défaut: Exploitez les méthodes par défaut des interfaces pour fournir des fonctionnalités communes sans obliger toutes les classes qui les mettent en œuvre à les surcharger.
• Documentation: Documentez l'objectif de chaque interface et les méthodes qu'elle déclare. Cela permet aux autres développeurs de comprendre le contrat que les classes d'implémentation doivent remplir.
• Cohérence: Veiller à la cohérence des conventions de dénomination et des signatures de méthodes entre les interfaces et leurs implémentations, dans un souci de clarté et de facilité de maintenance.

interface Drivable {
    void drive();
}

interface Fillable {
    void fillFuel();
}

public class Truck implements Drivable, Fillable {
    public void drive() {
        System.out.println("Truck is driving");
    }

    public void fillFuel() {
        System.out.println("Filling truck with fuel");
    }
}