1. Interface: une "classe spéciale" qui résume les classes plus approfondies et ne peut contenir des méthodes abstraites de l'interface. L'interface ne se soucie pas des données d'état interne de la classe et définit les spécifications à laquelle un lot de classes est conforme. (Il stipule seulement que certaines méthodes doivent être fournies dans ce lot de classes et que la fourniture de ces méthodes peut répondre aux exigences réelles).
Dans le langage de programmation Java, c'est un type abstrait, une collection de méthodes abstraites et des interfaces sont généralement déclarées comme interface. Une classe hérite des méthodes abstraites de l'interface en héritant de l'interface.
Les interfaces ne sont pas des classes, et la façon dont ils écrivent des interfaces sont très similaires aux classes, mais elles appartiennent à différents concepts. La classe décrit les propriétés et les méthodes d'un objet. L'interface contient les méthodes à implémenter par la classe.
À moins que la classe qui implémente une interface ne soit une classe abstraite, la classe définit toutes les méthodes de l'interface.
L'interface ne peut pas être instanciée, mais peut être implémentée. Une classe qui implémente une interface doit implémenter toutes les méthodes décrites dans l'interface, sinon elle doit être déclarée comme une classe abstraite. De plus, en Java, les types d'interface peuvent être utilisés pour déclarer une variable, ils peuvent être un pointeur nul ou lié à un objet implémenté avec cette interface.
Définition: [modificateur] Le nom de l'interface de l'interface étend l'interface parent 1, l'interface d'attribution 2, ... // non étend l'interface parentale 1 ... est de définir l'interface
{
// zéro à plusieurs définitions constantes ...
// zéro à plusieurs définitions de méthode d'instance abstraite ...
}
[Syntaxe Description]: 1. Le modificateur peut être public ou omis. Si le caractère de contrôle d'accès public est omis, c'est l'autorisation d'accès aux packages.
2. Tous les membres de l'interface sont modifiés publiquement car l'interface est publique et est accessible par toutes les classes. La modification par défaut de l'attribut dans l'interface est: publicStaticFinal. Que l'attribut soit écrit ou non, la modification par défaut de la même méthode est: publicAbstract, Classe interne: publicStatic. Ils seront ajoutés par défaut.
3. Il ne peut pas y avoir de constructeurs dans les membres, et il ne peut pas y avoir de blocs d'initialisation.
4. Un fichier source Java ne peut définir que dans le plus une seule interface, car elle est modifiée publiquement, et le nom stocké doit être le même que le nom de la classe modifiée publiquement, et l'interface peut être considérée comme une classe spéciale.
2. Héritage de l'interface: une interface peut avoir plusieurs interfaces parentales directes, et une interface ne peut hériter que des interfaces, mais pas des classes.
[Remarque]: a. L'interface enfant hérite de l'interface parent et obtiendra toutes les méthodes abstraites, les attributs constants, les classes internes et autres définitions définies dans l'interface parent.
3. Utilisation de l'interface: Syntaxe: [modificateur] La classe de classe étend la classe parent implémente l'interface 1, interface 2 ... {Classe Body}.
【Précautions】
un. Description: Une classe peut hériter d'une classe parent et de plusieurs interfaces en même temps, mais les étendues doivent être placées après des outils.
né L'interface ne peut pas créer une instance, mais elle peut déclarer des variables, mais elle doit se référer à l'objet de sa classe d'implémentation.
c. L'objectif principal est d'être mis en œuvre par classe.
d. Méthode d'implémentation: utilisez le mot-clé des outils
e. Une fois qu'une classe a hérité d'une interface, elle doit entièrement implémenter toutes les méthodes abstraites définies dans ces interfaces (c'est-à-dire réécrire ces méthodes de classe dans la sous-classe). Sinon, s'il n'est pas entièrement implémenté, cette classe ne peut être définie que comme une classe abstraite.
f. Lorsque vous remplacez la méthode d'interface, le modificateur ne peut être plus grand ou égal que la classe parent, il doit donc également être un modificateur public.
g. Toutes les variables de type d'interface peuvent être directement attribuées aux variables de type d'objet.
Publiez l'exemple de code (cité sur le java fou de Li Gang):
// Définir une sortie d'interface de sortie d'interface {// L'attribut ne peut être défini que comme des constantes int max_cache_line = 50; // définir principalement l'espace de stockage // La méthode abstraite définie dans l'interface ne peut être que publique void out (); void getData (String msg); } // Définir un produit d'interface de produit d'interface {int getProduceTime (int a); } // Laissez la classe d'imprimante implémente l'interface définie, l'imprimante de classe publique implémente la sortie, Product {private String [] printdata = new String [max_cache_line]; private int datanum = 0; public void out () // réécriture la méthode de sortie de l'interface parent {while (datanum> 0) {System.out.println ("print print" + printdata [0]); System.ArrayCopy (printdata, 1, printdata, 0, - datanum); }} public void getData (String msg) // réécriture la méthode de sortie de l'interface parent {if (datanum> = max_cache_line) {System.out.println ("full"); } else {printData [datanum ++] = msg; }} public int getProduceTime (int a) // réécriture la méthode du produit d'interface parent {return a = a; } public static void main (String [] args) {// L'interface parent peut déclarer des variables, mais ne peut pas créer des instances, le polymorphisme: la déclaration de sortie, mais l'instance créée est une sortie d'imprimante o = new imprimante (); O.getData ("xiuxiu"); O.out (); // appelle directement la méthode de sortie // L'interface parent peut déclarer des variables, mais ne peut pas créer des instances, le polymorphisme: la déclaration de sortie, mais l'instance créée est le produit d'imprimante p = new imprimante (); System.out.println (P.GetProduduTime (82)); // Toutes les variables de référence de type d'interface peuvent être directement attribuées à l'objet de variable d'objet obj = p; Objet obj1 = o; }}4. similitudes et différences entre les classes abstraites et les interfaces:
même:
1. Tous sont des méthodes abstraites.
2. Aucune instance ne peut être créée.
3. Les sous-classes doivent implémenter toutes les méthodes abstraites en leur sein après les avoir hérités. S'ils ne sont pas entièrement mis en œuvre, la classe ne peut être définie que comme une classe abstraite.
Différent:
1. Il ne peut y avoir que des méthodes abstraites dans l'interface et des méthodes ordinaires dans la classe abstraite.
2. Les attributs de la classe d'interface ont le modificateur publicStaticFinal par défaut, mais les attributs de la classe abstrait peuvent être ordinaires.
3. L'interface n'a pas de bloc d'initialisation, mais elle se trouve dans la classe abstraite.
4. Une interface peut avoir plusieurs interfaces parentales, mais une classe abstraite ne peut avoir qu'une classe parent.
Résumer
Ce qui précède concerne les exemples d'interface et d'utilisation en Java. J'espère que ce sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler.