Classe abstraite vs interface en Java - Différence entre elles

Différence clé entre la classe abstraite et l'interface en Java

  • Dans Interface, une classe peut implémenter plusieurs interfaces, alors qu'elle ne peut hériter que d'une seule classe abstraite.
  • Dans l'interface n'a pas de modificateurs d'accès. Tout ce qui est défini dans l'interface est supposé avoir un modificateur public, alors que la classe abstraite peut avoir un modificateur d'accès.
  • L'interface ne peut pas contenir de champs de données, alors que la classe abstraite peut avoir des champs de données.
  • Les interfaces aident à définir les capacités périphériques d'une classe, tandis qu'une classe abstraite définit l'identité d'une classe.

Interface vs classe abstraite en Java

Qu’est-ce que la classe abstraite ?

Une classe qui a le mot-clé abstract dans sa déclaration est appelée classe abstraite. Les classes abstraites doivent avoir zéro ou plusieurs méthodes abstraites. c'est-à-dire des méthodes sans corps. Il peut avoir plusieurs méthodes concrètes.

Les classes abstraites vous permettent de créer des plans pour des classes concrètes. Mais la classe héritière doit implémenter la méthode abstraite.

Les classes abstraites ne peuvent pas être instanciées.

Raisons importantes d’utiliser les interfaces

  • Les interfaces sont utilisées pour réaliser abstraction.
  • Conçu pour prendre en charge la résolution de méthode dynamique au moment de l'exécution
  • Cela vous aide à obtenir un couplage lâche.
  • Permet de séparer la définition d'une méthode de la hiérarchie d'héritage

Raisons importantes d’utiliser la classe abstraite

  • Les classes abstraites offrent des fonctionnalités par défaut pour les sous-classes.
  • Fournit un modèle pour les futurs cours spécifiques
  • Vous aide à définir une interface commune pour ses sous-classes
  • La classe abstraite permet la réutilisation du code.

Qu'est-ce qu'Interface ?

L'interface est un modèle qui peut être utilisé pour implémenter une classe. L'interface ne contient aucune méthode concrète (méthodes qui ont du code). Toutes les méthodes d'une interface sont des méthodes abstraites.

Une interface ne peut pas être instanciée. Cependant, les classes qui implémentent des interfaces peuvent être instanciées. Les interfaces ne contiennent jamais de variables d'instance mais elles peuvent contenir des variables finales statiques publiques (c'est-à-dire des variables de classe constantes)

Différence entre l'interface et la classe abstraite en Java

Une classe abstraite vous permet de créer des fonctionnalités que les sous-classes peuvent implémenter ou remplacer, tandis qu'une interface vous permet uniquement d'énoncer une fonctionnalité mais pas de l'implémenter. Une classe ne peut étendre qu'une seule classe abstraite tandis qu'une classe peut implémenter plusieurs interfaces.

Paramètres Interfaces Classe abstraite
Vitesse Lent Fast
Héritages multiples Implémenter plusieurs interfaces Une seule classe abstraite
Structure Méthodes abstraites Méthodes abstraites et concrètes
Quand l’utiliser Amélioration future Pour éviter l’indépendance
Héritage/Mise en œuvre Une classe peut implémenter plusieurs interfaces La classe ne peut hériter que d'une seule classe abstraite
Implémentation par défaut Lors de l'ajout de nouveaux éléments à l'interface, c'est un cauchemar de trouver tous les implémenteurs et d'implémenter les éléments nouvellement définis. Dans le cas d'une classe abstraite, vous pouvez profiter de l'implémentation par défaut.
Modificateurs d'accès L'interface n'a pas de modificateurs d'accès. Tout ce qui est défini à l'intérieur de l'interface est supposé être un modificateur public. La classe abstraite peut avoir un modificateur d'accès.
Quand l’utiliser Il est préférable d'utiliser l'interface lorsque diverses implémentations partagent uniquement la signature de méthode. Hiérarchie polymorphe des types valeur. Il doit être utilisé lorsque diverses implémentations du même type partagent un comportement commun.
Champs de données l'interface ne peut pas contenir de champs de données. la classe peut avoir des champs de données.
Héritage multiple par défaut Une classe peut implémenter de nombreuses interfaces. Une classe hérite d'une seule classe abstraite.
Implémentation Une interface est abstraite et ne peut donc fournir aucun code. Une classe abstraite peut donner un code complet par défaut qui doit être remplacé.
Utilisation des modificateurs d'accès Vous ne pouvez pas utiliser de modificateurs d'accès pour la méthode, les propriétés, etc. Vous pouvez utiliser une classe abstraite contenant des modificateurs d'accès.
Utilisation Les interfaces aident à définir les capacités périphériques d’une classe. Une classe abstraite définit l'identité d'une classe.
Champs définis Aucun champ ne peut être défini Une classe abstraite vous permet de définir à la fois des champs et des constantes
Droit des successions Une interface peut hériter de plusieurs interfaces mais ne peut pas hériter d'une classe. Une classe abstraite peut hériter d'une classe et de plusieurs interfaces.
Constructeur ou destructeurs Une interface ne peut pas déclarer de constructeurs ou de destructeurs. Une classe abstraite peut déclarer des constructeurs et des destructeurs.
Limite des extensions Il peut étendre n’importe quel nombre d’interfaces. Il ne peut étendre qu’une seule classe ou une classe abstraite à la fois.
Mot-clé abstrait Dans un mot-clé d'interface abstraite, est facultatif pour déclarer une méthode comme abstraite. Dans une classe abstraite, le mot-clé abstract est obligatoire pour déclarer une méthode comme abstraite.
Type de classe Une interface ne peut avoir que des méthodes abstraites publiques. Une classe abstraite a des méthodes abstraites protégées et publiques.

Exemple de code pour l'interface et la classe abstraite en Java

Following est un exemple de code pour créer une interface et une classe abstraite en Java

Syntaxe de l'interface

interface name{
//methods
}

Exemple d'interface Java :

interface Pet {
    public void test();
}
class Dog implements Pet {
    public void test() {
        System.out.println("Interface Method Implemented");
    }
    public static void main(String args[]) {
        Pet p = new Dog();
        p.test();
    }
}

Syntaxe de classe abstraite

abstract class name{
    // code
}

Exemple de classe abstraite :

abstract class Shape {
    int b = 20;
    abstract public void calculateArea();
}

public class Rectangle extends Shape {
    public static void main(String args[]) {
        Rectangle obj = new Rectangle();
        obj.b = 200;
        obj.calculateArea();
    }
    public void calculateArea() {
        System.out.println("Area is " + (b * b));
    }
}