Classe abstraite Vs. Interface en Java : explication avec des exemples

Les classes abstraites et les interfaces sont utilisées pour l'abstraction en Java. L'abstraction dans la programmation orientée objet fait référence à la dissimulation des détails d'implémentation aux utilisateurs finaux.

Dans l'abstraction, vous pouvez savoir quelles sont les fonctionnalités, mais vous ne pouvez pas savoir comment elles ont été implémentées.

Examinons chacun d'eux et essayons de comprendre pourquoi ils sont utilisés.

Abstract Class

Une classe qui ne peut pas être instanciée en tant qu'objet et qui peut contenir ou non des méthodes abstraites est appelée une classe abstraite dans Java. Une méthode abstraite est une méthode qui n'a pas de corps d'implémentation lorsqu'elle est déclarée.

Vous pouvez créer une classe abstraite en spécifiant le abstract mot-clé avant le class mot-clé.

abstract class abstractClass {
    void run() {
        System.out.println("ran");
    }
}

Une classe abstraite peut être étendue par d'autres classes. En d'autres termes, il peut également être sous-classé.

abstract class AbstractClass {
    void run() {
        System.out.println("ran");
    }
}

class ExtendingAbstractClass extends AbstractClass {
    void newMethod() {
        System.out.println("new");
    }

    @Override
    void run() {
        System.out.println("override");
    }
}

Les classes abstraites sont utilisées pour implémenter des méthodes communes parmi plusieurs classes qui étendent une classe abstraite donnée. De plus, la possibilité de définir des méthodes abstraites à l'intérieur de classes abstraites les rend incroyablement utiles pour les classes qui ont des méthodes similaires mais avec des implémentations différentes. Prenons un exemple.

Considérez une voiture qui possède certaines fonctionnalités, telles que le démarrage, l'arrêt, la marche arrière, etc. Ces fonctionnalités sont communes à tous les types de voitures.

Mais qu'en est-il des fonctionnalités d'automatisation telles que l'auto-conduite ? La mise en œuvre de ces fonctionnalités peut différer selon les types de voitures. Voyons comment vous pouvez créer un programme orienté objet qui lui est lié.

Tout d'abord, créez un Car classe qui sera étendue par plusieurs classes de différents types de voitures.

abstract class Car {
    void start() {
        // implementation
        System.out.println("runs car");
    }

    void stop() {
        // implementation
        System.out.println("engine stops");
    }

    void reverse() {
        // implementation
        System.out.println("reverse mode enabled");
    }

    abstract void selfDrive();
}

Procédé start(), stop() et reverse() sont des méthodes communes à toutes les voitures. Leur implémentation est donc déjà définie dans la classe Car elle-même. Cependant, un certain type de voiture peut avoir différentes implémentations du mode de conduite autonome. Et ainsi, vous pouvez définir selfDrive() comme une méthode abstraite et la mettre en œuvre de différentes manières dans différentes classes de différents types de voitures.

class CarTypeA extends Car {
    @Override
    void start() {
        super.start();
    }

    @Override
    void stop() {
        super.stop();
    }

    @Override
    void reverse() {
        super.reverse();
    }

    void selfDrive() {
        // custom implementation
        System.out.println("Type A self driving mode enabled");
    }
}

class CarTypeB extends Car {
    // ...all similar methods

    void selfDrive() {
        // custom implementation
        // different implementation than CarTypeB
        System.out.println("Type B self driving mode enabled");
    }
}

Il est important de noter que, si une sous-classe n'implémente pas toutes les méthodes abstraites définies dans la classe abstraite, elle doit être déclarée elle-même comme une classe abstraite.

Interface

Une interface est un moyen d'indiquer à une classe quelles méthodes doivent être implémentées par elle. Par exemple, si vous considérez l'exemple d'une voiture, elle a quelques fonctions de base. Il peut démarrer, se déplacer et s'arrêter. Ces fonctions sont communes à toutes les voitures.

Ainsi, si vous implémentez une interface d'une voiture dans une classe, vous devez implémenter toutes les méthodes pour que la voiture fonctionne correctement et en toute sécurité.

Semblable aux classes abstraites, nous ne pouvons pas instancier ou créer des objets d'une interface. Elle peut être considérée comme une classe entièrement abstraite car elle ne contient que des méthodes abstraites, c'est-à-dire des méthodes sans corps d'implémentation.

Vous pouvez créer une interface en utilisant le interface mot-clé.

interface CAR {
    void start();
    void stop();
    void move();
}

Implémenter une interface en utilisant le implements mot clé lors de la définition d'une classe.

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

    public void stop() {
        System.out.println("stopped");
    }

    public void move() {
        System.out.println("running");
    }
}

Similarity

Aucune instanciation en tant qu'objet n'est la seule chose que les classes abstraites et les interfaces ont en commun.

Differences

When to use abstract class and interface?

Utilisez des classes abstraites lorsque :

• Vous souhaitez partager des méthodes et des champs communs entre plusieurs classes.
• Déclarer non-static et non-final champs afin de modifier l'état de l'objet auquel ils sont liés.

Vous pouvez utiliser des interfaces lorsque :

• Vous souhaitez définir le comportement d'une classe qui implémente l'interface, mais vous ne vous souciez pas de la manière dont elle est implémentée.
• Vous voulez vous assurer qu'une classe implémente toutes les méthodes pour fonctionner correctement.

Mot de la fin

Les interfaces sont principalement utilisées pour créer des API car elles peuvent fournir une structure pour implémenter des fonctionnalités sans se soucier de l'implémentation réelle.

Les classes abstraites sont généralement utilisées pour partager des méthodes abstraites et non abstraites communes entre plusieurs classes, qui étendent la classe abstraite pour rendre le code plus réutilisable.

En savoir plus sur Java à l'aide de ces cours en ligne pour java. Vous préparez un entretien sur Java ? Voilà quelque questions d'entretien sur la programmation orientée objet.