L'essence de l'interface - Une interface est une classe abstraite spéciale. Cette classe abstraite contient uniquement la définition des constantes et des méthodes, sans l'implémentation de variables et de méthodes.
Les interfaces peuvent avoir certaines choses que les classes abstraites ont. Si toutes les méthodes d'une classe abstraite sont abstraites, aucune méthode n'a besoin d'être implémentée par cette classe abstraite, et toutes les variables de cette classe abstraite sont des variables statiques, ce sont toutes des variables qui ne peuvent pas. être modifié (final). À ce stade, une telle classe abstraite peut être définie comme une interface. Le format pour définir une classe en tant qu'interface consiste à remplacer le mot-clé class qui déclare la classe par le mot-clé interface qui déclare l'interface.
Une interface est une classe abstraite spéciale. Dans cette classe abstraite, toutes les méthodes sont des méthodes abstraites, et les attributs (c'est-à-dire les variables membres) de cette classe abstraite sont déclarés comme « noms d'attributs de type final statique public ». De cette façon, la déclaration par défaut est "public static final", c'est-à-dire que les variables membres à l'intérieur sont publiques, statiques et ne peuvent pas être modifiées. Par conséquent, lorsque vous déclarez une constante dans une interface, vous pouvez l'écrire sous la forme "nom de constante de type final statique public = valeur (valeur)", ou vous pouvez l'écrire directement sous la forme de "nom de constante de type = valeur (valeur )" tel que : "public static final int id =10" peut être directement écrit sous la forme "int id=10", car les déclarations de propriétés par défaut dans l'interface sont toutes "public static final", donc "public static final " peut être omis. La méthode abstraite déclarée dans l'interface n'a pas besoin d'être identifiée par le mot-clé abstract, car toutes les méthodes de l'interface sont abstraites, donc le mot-clé "abstract" est omis par défaut. Par exemple, si vous déclarez ces trois mots dans une interface. , Méthodes : "public void start()", "public void run()", "public void "stop()" ne sont pas identifiés par le mot-clé abstract devant ces trois méthodes, mais ce sont des méthodes abstraites, car les méthodes déclarées dans l'interface sont toutes des méthodes abstraites, donc le mot-clé abstract sera omis dans les méthodes abstraites du interface Abandonné, car les méthodes déclarées par défaut sont abstraites. , il n'est donc pas nécessaire d'écrire le mot "abstract". Ceci est différent de la déclaration de méthodes abstraites dans des classes abstraites. Lorsque vous déclarez des méthodes abstraites dans des classes abstraites, vous devez utiliser le mot-clé "abstract", et dans les interfaces, vous pouvez omettre ". abstract" lors de la déclaration de méthodes abstraites. Remarque : La méthode abstraite déclarée dans l'interface est "publique" par défaut et ne peut être que "publique". La raison pour laquelle elle est déclarée de cette manière est de corriger les problèmes qui surviennent facilement lorsque l'héritage multiple se produit en C++. en C++ est sujet à des problèmes.Le problème est que si plusieurs classes parentes à héritage multiple ont les mêmes variables membres, il sera assez difficile de les référencer et divers problèmes se produiront pendant le fonctionnement. Afin de corriger ce problème, JAVA a modifié toutes les variables membres de l'interface en static final. Si la variable membre est de type statique, alors la variable membre appartient à la classe entière, plutôt que d'être exclusive à un certain objet. Pour l'héritage multiple, un objet de sous-classe contient en fait plusieurs objets de classe parent, tandis que pour l'héritage unique, il n'y a qu'un seul objet de classe parent dans l'objet de sous-classe. Les objets de sous-classe à héritage multiple ont plusieurs objets de classe parent, et il peut y avoir des variables membres en double entre ces objets de classe parent, ce qui est très sujet à des problèmes. Par conséquent, ce problème peut être évité en JAVA en utilisant des interfaces pour implémenter l'héritage multiple. En tant qu'interface, une classe peut hériter de l'interface (ou implémenter l'interface). Il s'agit également d'un héritage multiple. Les variables membres de l'interface ne sont pas exclusives à un certain objet. Ce sont toutes des variables membres statiques et appartiennent à la classe entière. .Par conséquent, peu importe si une classe implémente plusieurs interfaces et il n'y aura pas de conflit entre les objets. L'implémentation de plusieurs interfaces permet également d'obtenir un héritage multiple et d'éviter les problèmes liés à l'héritage multiple. C'est l'avantage d'utiliser des interfaces pour implémenter l'héritage multiple.
1. Définir l'interface
Utilisez interface pour définir une interface. Les définitions d'interface sont similaires aux définitions similaires. Elles sont également divisées en déclarations d'interface et corps d'interface. Le corps de l'interface se compose de deux parties : la définition de constante et la définition de méthode. Le format de base pour définir une interface est le suivant :
Nom de l'interface de l'interface [Modifier] [étend la liste des noms de l'interface parent]{
[public] [statique] [final] constante ;
méthode [publique] [abstraite] ;
}
Modificateur : Facultatif, utilisé pour spécifier l'autorisation d'accès à l'interface, la valeur facultative est publique. En cas d'omission, les autorisations d'accès par défaut sont utilisées.
Nom de l'interface : paramètre obligatoire, utilisé pour spécifier le nom de l'interface. Le nom de l'interface doit être un identifiant Java légal. Généralement, les majuscules sont requises.
extends : Liste de noms d'interface parent : paramètre facultatif, utilisé pour spécifier de quelle interface parent hérite l'interface à définir. Lors de l'utilisation du mot-clé extends, le nom de l'interface parent est un paramètre obligatoire.
Méthodes : Les méthodes de l'interface sont uniquement définies mais non implémentées.
Par exemple, définissez une interface de calcul, dans laquelle un PI constant et deux méthodes sont définis. Le code spécifique est le suivant :
public interface CalInterface { final float PI=3.14159f;//Définir la constante PI utilisée pour représenter pi float getArea(float r);//Définir une méthode de calcul de surface getArea() float getCircumference(float r);// Définir un méthode getCircumference() pour calculer le périmètre } Avis:
Comme pour les fichiers de classe Java, le nom du fichier d'interface doit être le même que le nom de l'interface.
2. Implémenter l'interface
Une fois qu’une interface est définie, elle peut être implémentée dans une classe. Pour implémenter une interface dans une classe, vous pouvez utiliser le mot clé Implements, et son format de base est le suivant :
[Modificateur] classe <nom de classe> [étend le nom de la classe parent] [implémente la liste d'interfaces]{
............
}
Modificateur : Paramètre facultatif, utilisé pour spécifier l'autorisation d'accès de la classe. Les valeurs facultatives sont publiques, abstraites et finales.
Nom de classe : paramètre obligatoire, utilisé pour spécifier le nom de la classe. Le nom de la classe doit être un identifiant Java légal. Généralement, les majuscules sont requises.
extends parent class name : paramètre facultatif, utilisé pour spécifier de quelle classe parent hérite la classe à définir. Lors de l'utilisation du mot-clé extends, le nom de la classe parent est un paramètre obligatoire.
Implements Interface List : paramètre facultatif utilisé pour spécifier les interfaces que cette classe implémente. Lors de l'utilisation du mot-clé Implements, la liste des interfaces est un paramètre obligatoire. Lorsqu'il y a plusieurs noms d'interface dans la liste des interfaces, séparez-les par des virgules.
Lors de l'implémentation d'une interface dans une classe, le nom de la méthode, le type de valeur de retour, le nombre et le type de paramètres doivent être exactement les mêmes que ceux de l'interface, et toutes les méthodes de l'interface doivent être implémentées. Par exemple, écrivez une classe nommée Cire qui implémente l'interface Calculate définie dans la section 5.7.1. Le code spécifique est le suivant :
public class Cire implémente CalInterface { public float getArea(float r) { float area=PI*r*r;//Calculer la zone du cercle et l'affecter à la zone de retour de la zone variable;//Renvoyer la zone du cercle calculée} public float getCircumference (float r) { float circumference=2*PI*r; //Calculer la circonférence du cercle et l'attribuer à la circonférence variable return circumference; //Renvoyer la circonférence calculée} public static void main(String[] args) { Cire c = new Cire(); float f = c.getArea(2.0f); System.out.println(Float.toString(f)); Dans l'héritage de classe, un seul héritage peut être effectué, mais lors de l'implémentation d'une interface, plusieurs interfaces peuvent être implémentées en même temps et chaque interface est séparée par une virgule ",".
À ce stade, des conflits de noms de constantes ou de méthodes (dans plusieurs interfaces) peuvent survenir. Lors de la résolution de ce problème, si les constantes sont en conflit, vous devez spécifier explicitement l'interface de la constante. Cela peut être réalisé via "interface name.constant". Si un conflit de méthode survient, vous ne devez implémenter qu’une seule méthode.