Quand utiliser l’abstraction et quand utiliser les interfaces ?

L'éditeur PHP Zimo vous emmène explorer le timing de l'utilisation des classes abstraites et des interfaces en Java. En programmation Java, choisir quand utiliser les classes abstraites et quand utiliser les interfaces est une décision importante. Cet article répondra pour vous à cette question courante et vous aidera à mieux comprendre comment choisir la classe abstraite ou l'interface appropriée dans différentes situations.

Contenu de la question

Je comprends vaguement la différence entre l'abstraction et l'interface, mais ce que je n'arrive tout simplement pas à comprendre, c'est quand utiliser l'abstraction et quand utiliser l'interface. De quelles variables ai-je besoin pour sélectionner une abstraction d’interface et vice versa ? La plupart des réponses en ligne visent à montrer la différence, mais même moi, je les comprends. Je ne sais pas quand c’est le plus approprié.

Solution

L'ancienne règle générale est la suivante : restez fidèle aux interfaces jusqu'à ce que vous soyez obligé d'écrire des classes abstraites.

En Java, un interface est un type non instanciable qui définit une interface publique à laquelle d'autres types peuvent choisiradhérer.

• Les interfaces peuvent déclarer des méthodes publiques, qui doivent être définies par leurs implémenteurs. Toutes ces méthodes sont implicitement abstract，因此您不需要使用单词 abstract.
• Dans les anciennes versions de Java, les interfaces ne pouvaient pas avoir d'implémentations par défaut, donc chaque méthode utilisait l'implémentation par défaut utilisée dans la classe à moins d'être remplacée. abstract。现在情况已不再是这样，接口现在可以具有在 implement
Dans la dernière version de Java, les interfaces peuvent déclarer
• méthodes d'assistance. Ceux-ci peuvent aider avec les implémentations par défaut. private
Les interfaces ne peuvent jamais avoir de constructeurs ou de variables d'instance.
Une classe peut
• avoir plusieurs interfaces. implement

méthode, même si vous aurez généralement envie de faire cela. abstract 类 只是一个无法实例化的类。抽象类不需要定义任何 abstract

Les classes abstraites peuvent déclarer des méthodes avec n'importe quelle visibilité : public,
• , protected et package-private. public、private、protected
Les classes abstraites peuvent implémenter des méthodes ou les conserver comme abstraites. Les méthodes des classes abstraites
• ne sont pas abstract。抽象类中的方法不是隐式 abstract implicitement abstraites et doivent être marquées comme telles.
• Les classes abstraites peuvent avoir des constructeurs,extending 类必须使用 superappeler des constructeurs dans leurs propres constructeurs. Les classes abstraites peuvent avoir des variables d'instance de n'importe quelle visibilité et fonctionnent comme des variables d'instance dans n'importe quelle classe parent.
• La seule extend 一个类，可以是 abstract 类，也可以是具体类。类的 abstractness d'une classe ne change pas le nombre de superclasses qu'elle est autorisée à avoir.

abstract classes 应该是例外而不是常态。如果您需要维护某些内部状态，同时还让子类定义您自己的行为，则应该使用抽象类。一个很好的例子来自 java swing gui 库：AbstractButton。 abstractbutton 是行为模糊地类似于窗口中按钮的事物的抽象父代，包括按钮、切换按钮和菜单中的项目。任何人都可以子类化 abstractbutton 并实现其成员来定义类似按钮的显示。但是 abstractbutton 还必须维护大量内部状态（其中大部分来自 jcomponent) pour communiquer avec la fenêtre ainsi qu'avec l'ensemble de l'api swing.

Si vous souhaitez définir une interface publique pour une collection de types, utilisez interface. Si vous souhaitez fournir une implémentation par défaut pour certaines de ces méthodes et utiliser une version Java publiée après 2014, utilisez une interface. Si vous avez besoin d’une implémentation par défaut mais que vous êtes toujours bloqué dans les années 2000, utilisez des classes abstraites. Quelle que soit la version de Java, si vous avez besoin d'un état privé (tel que des variables d'instance) ou d'une initialisation personnalisée (telle que des constructeurs), utilisez des classes abstraites.

Interface :

Supposons que vous ayez une interface comme :

interface animal {
  string makenoise();
}

Et plusieurs classes qui mettent en œuvre l'animal :

class cat implements animal {
    string makenoise() {
        return "meow";
    }
}

class dog implements animal {
    string makenoise() {
        return "woof";
    }
}

Vous pouvez désormais utiliser des interfaces comme types de retour, afin que les méthodes puissent renvoyer cat 或 dog.

string makeanimalmakenoise(int animalid) {
    animal animal = pretendanimalservice.getdogorcat(animalid);

    animal.makenoise();
}

Cours abstrait :

Supposons que vous ayez un cours abstrait :

abstract class animal {
    public string makenoise() {
        return "whistle";
    }

    abstract public string getname();
}

Maintenant, toute classe qui l'étend doit implémenter la méthode getname :

class Cat extends Animal {
    String getName() {
        return "Pussy";
    }
}

class Dog extends Animal {
    String getName() {
        return "Fido";
    }
}

Les deux classes ci-dessus implémentent les méthodes getname 方法，但它们也可以访问父类 makenoise requises, mais elles ont également accès à la méthode makenoise de la classe parent, qui peut également être remplacée si nécessaire.

Il est également important de noter d'autres différences, ce sont :

• Vous ne pouvez étendre qu'une seule classe abstraite, mais vous pouvez en implémenter plusieurs interface.
• Les interfaces doivent être utilisées lorsque différents types doivent avoir les mêmes signatures de méthode, et les classes abstraites doivent être utilisées lorsque les implémentations partagent un comportement commun.
• Ils ne s’excluent pas mutuellement.
• Les interfaces ne peuvent avoir que des méthodes publiques, tandis que les classes abstraites peuvent avoir des méthodes publiques et des méthodes protégées.

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!