Pour la programmation orientée objet, l'abstraction est l'une de ses principales caractéristiques. En Java, l'abstraction OOP peut se refléter sous deux formes: interfaces et classes abstraites. Il y a trop de similitudes et trop de différences entre les deux. Beaucoup de gens pensent qu'ils peuvent être utilisés de manière interchangeable lorsqu'ils sont débutants, mais en fait ils ne le sont pas. Aujourd'hui, nous découvrirons les interfaces et les cours abstraits en Java. Voici le plan du répertoire de cet article:
1. Classe abstraite
2. Interface
3. La différence entre les classes abstraites et les interfaces
1. Classe abstraite
Avant de comprendre les classes abstraites, comprenons d'abord les méthodes abstraites. Une méthode abstraite est une méthode spéciale: elle n'a que des déclarations, mais aucune implémentation concrète. Le format de déclaration d'une méthode abstrait est:
abstrait void fun ();
Les méthodes abstraites doivent être modifiées avec le mot-clé abstrait. Si une classe contient des méthodes abstraites, cette classe est appelée une classe abstraite. La classe abstraite doit être modifiée avec le mot-clé abstrait avant la classe. Étant donné que les classes abstraites contiennent des méthodes sans implémentations concrètes, les objets ne peuvent pas être créés à l'aide de classes abstraites.
Un problème doit être noté ci-dessous: dans le livre "Java Programming Thought", les classes abstraites sont définies comme "des classes contenant des méthodes abstraites", mais plus tard, il a été constaté que si une classe ne contient pas de méthodes abstraites et est simplement modifiée avec abstraite, c'est aussi une classe abstraite. En d'autres termes, les classes abstraites ne doivent pas nécessairement contenir des méthodes abstraites. Je pense personnellement que c'est une question obstinée, car si une classe abstraite ne contient pas de méthodes abstraites, pourquoi devrait-elle être conçue comme une classe abstraite? N'oubliez donc pas ce concept pour le moment, et il n'est pas nécessaire de creuser pourquoi.
[public] Résumé Class classname {Abstract Void Fun ();}De cela, nous pouvons voir que des classes abstraites existent pour l'héritage. Si vous définissez une classe abstraite mais ne l'hérite pas, elle équivaut à créer cette classe abstraite en vain, car vous ne pouvez pas l'utiliser pour faire quoi que ce soit. Pour une classe parent, si l'une de ses méthodes est implémentée dans la classe parent n'a aucun sens et doit être mise en œuvre différemment en fonction des besoins réels de la sous-classe, cette méthode peut être déclarée comme une méthode abstraite, et cette classe devient une classe abstraite.
Les classes contenant des méthodes abstraites sont appelées classes abstraites, mais elles ne signifient pas que les méthodes abstraites ne peuvent être trouvées que dans les classes abstraites. Comme les classes ordinaires, ils peuvent également avoir des variables membres et des méthodes de membres ordinaires. Notez qu'il existe trois principales différences entre les classes abstraites et les classes ordinaires:
1) La méthode abstraite doit être publique ou protégée (car si elle est privée, elle ne peut pas être héritée par la sous-classe et que la sous-classe ne peut pas implémenter la méthode). Par défaut, c'est public.
2) Les classes abstraites ne peuvent pas être utilisées pour créer des objets;
3) Si une classe hérite d'une classe abstraite, la sous-classe doit implémenter la méthode abstraite de la classe parent. Si la sous-classe n'implémente pas la méthode abstraite de la classe parent, la sous-classe doit également être définie comme une classe abstraite.
Dans d'autres aspects, il n'y a pas de différence entre les classes abstraites et les classes ordinaires.
2. Interface
L'interface, appelée interface en anglais, en génie logiciel, les interfaces se réfèrent généralement aux méthodes ou fonctions à appeler d'autres. De cela, nous pouvons comprendre l'intention originale des concepteurs de langues Java, qui est une abstraction de comportement. En Java, la forme d'une interface est la suivante:
[public] interface interfacename {}
Les interfaces peuvent contenir des variables et des méthodes. Cependant, il convient de noter que les variables de l'interface seront implicitement spécifiées en tant que variables finales statiques publiques (et ne peuvent être que des variables finales statiques publiques, et la modification privée rapportera une erreur de compilation), tandis que les méthodes seront implicitement spécifiées en tant que méthode abstraite publique et ne pourra être que la méthode abstracte du public (en utilisant d'autres mots clés, tels que les méthodes protégés, statiques, natiques, et ne rapporteront pas une compilation), et toutes ont des implémentations spécifiques, c'est-à-dire que les méthodes de l'interface doivent être des méthodes abstraites. De là, nous pouvons vaguement voir la différence entre une interface et une classe abstraite. Une interface est un type extrêmement abstrait. Il est plus "abstrait" qu'une classe abstraite et ne définit généralement pas les variables dans une interface.
Pour faire en sorte qu'une classe suive un groupe spécifique d'interfaces, vous devez utiliser le mot-clé des outils, le format spécifique est le suivant:
class classname implémente interface1, interface2, [....] {}
On peut voir qu'une classe est autorisée à suivre plusieurs interfaces spécifiques. Si une classe non abstracte suit une interface, toutes les méthodes de cette interface doivent être implémentées. Pour les classes abstraites qui suivent une interface, les méthodes abstraites de cette interface peuvent ne pas être implémentées.
3. La différence entre les classes abstraites et les interfaces
1. Différences au niveau grammatical
1) Les classes abstraites peuvent fournir des détails de mise en œuvre des méthodes des membres, tandis que seules les méthodes abstraites publiques peuvent exister dans l'interface;
2) Les variables membres dans les classes abstraites peuvent être de différents types, tandis que les variables membre dans l'interface ne peuvent être que de type final statique public;
3) L'interface ne peut pas contenir de blocs de code statique et de méthodes statiques, tandis que les classes abstraites peuvent avoir des blocs de code statique et des méthodes statiques;
4) Une classe ne peut hériter qu'une seule classe abstraite, tandis qu'une classe peut implémenter plusieurs interfaces.
2. Différences au niveau de la conception
1) Les classes abstraites sont des abstractions de choses, c'est-à-dire les abstractions des classes, tandis que les interfaces sont des abstractions de comportement. Une classe abstraite résume toute la classe, y compris les propriétés et les comportements, mais une interface résume la partie de la classe (comportement). Pour donner un exemple simple, les avions et les oiseaux sont des choses différentes, mais ils ont tous une chose en commun, c'est-à-dire qu'ils volent tous. Ensuite, lors de la conception, l'avion peut être conçu comme un avion et un personnage d'oiseau, mais la caractéristique de vol ne peut pas être conçue comme une classe. Par conséquent, ce n'est qu'une caractéristique comportementale, pas une description abstraite d'un type de chose. À l'heure actuelle, le vol peut être conçu comme une mouche d'interface, y compris la méthode Fly (), puis l'avion et les oiseaux implémentent l'interface de la mouche en fonction de leurs propres besoins. Ensuite, comme pour différents types d'avions, tels que des avions de chasse, des avions civils, etc., il peut hériter directement de l'avion. Il est également similaire aux oiseaux. Différents types d'oiseaux peuvent hériter directement de la classe des oiseaux. De là, nous pouvons voir que l'héritage est une relation "oui ou non", tandis que la mise en œuvre de l'interface est une relation "oui ou non". Si une classe hérite d'une classe abstraite, la sous-classe doit être un type de classe abstraite, et la mise en œuvre de l'interface est une relation qui n'existe pas, par exemple si l'oiseau peut voler (ou s'il a les caractéristiques du vol). S'il peut voler, il peut réaliser cette interface. S'il ne peut pas voler, il ne réalisera pas cette interface.
2) Différents niveaux de conception, la classe abstraite est une conception de modèle, en tant que classe parent de nombreuses sous-classes. Et l'interface est un code de comportement, c'est une conception de rayonnement. Qu'est-ce que la conception du modèle? L'exemple le plus simple est que tout le monde a utilisé les modèles dans PPT. Si vous utilisez le modèle A pour concevoir PPT B et PPT C, la partie commune de PPT B et PPT C est le modèle A. Si leur partie publique doit être modifiée, il vous suffit de modifier le modèle A, et il n'est pas nécessaire de réchanger le PPT B et PPT C. Radiant Design, comme un ascenseur équipé d'une sorte d'alarme, une fois que l'alarme doit être mise à jour, toutes doivent être mises à jour. C'est-à-dire que pour les classes abstraites, si vous avez besoin d'ajouter de nouvelles méthodes, vous pouvez ajouter directement des implémentations spécifiques à la classe abstraite et les sous-classes ne peuvent pas être modifiées; Mais pour les interfaces, ce n'est pas possible. Si l'interface est modifiée, toutes les classes qui implémentent cette interface doivent être modifiées en conséquence.
Voyons l'exemple le plus diffusé sur Internet: Exemples de portes et d'alarmes: les portes ont deux actions: Open () et Close (). Pour le moment, nous pouvons définir ce concept abstrait à travers des classes et des interfaces abstraites:
Résumé Classe Door {public Abstract Void Open (); public abstrait void close ();}ou:
Porte d'interface {public abstract void open (); public abstrait void close ();}Mais maintenant, si nous avons besoin de la porte pour avoir la fonction d'alarme (), alors comment l'implémenter? Les deux idées suivantes sont fournies:
1) Mettez les trois fonctions dans la classe abstraite, mais de cette manière, toutes les sous-classes héritées de cette classe abstraite ont des fonctions d'alarme, mais certaines portes n'ont pas nécessairement des fonctions d'alarme;
2) Mettez ces trois fonctions dans l'interface. Les classes qui doivent utiliser les fonctions d'alarme doivent implémenter Open () et clôture () dans cette interface. Peut-être que cette classe n'a pas du tout les deux fonctions Open () et Close (), comme les alarmes incendie.
De là, nous pouvons voir que la porte est ouverte (), close () et alarm () appartiennent simplement à deux comportements dans différentes catégories. Open () et Close () appartiennent aux caractéristiques de comportement inhérentes de la porte elle-même, tandis que Alarm () appartient à des comportements supplémentaires étendus. Par conséquent, la meilleure solution consiste à concevoir l'alarme en tant qu'interface, y compris le comportement d'alarme () et la porte en tant que classe abstraite distincte, y compris les comportements ouverts et fermés. Une autre porte d'alarme est conçue pour hériter de la classe de porte et implémenter l'interface d'alarme.
interface alram {void Alarm ();} Résumé Classe Door {void open (); void close ();} class AlarmDoor étend la porte implémente l'alarme {void oepn () {// ..} void close () {// ..} void alarm () {// ...}}Ce qui précède est une compilation des interfaces Java et des classes abstraites. J'espère que cela peut aider les amis qui apprennent la programmation Java.