Interface Java

Interface (anglais : Interface) est un type abstrait dans le langage de programmation JAVA et est une collection de méthodes abstraites. Les interfaces sont généralement déclarées avec 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. La façon d'écrire des interfaces est très similaire aux classes, mais elles appartiennent à des concepts différents. Les classes décrivent les propriétés et les méthodes d'un objet. L'interface contient les méthodes implémentées par la classe.

À moins que la classe qui implémente l'interface ne soit une classe abstraite, la classe doit définir toutes les méthodes de l'interface.

L'interface ne peut pas être instanciée, mais elle 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 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 être liés à un objet qui implémente cette interface.

Similarités entre interfaces et classes :

Une interface peut avoir plusieurs méthodes.
Le fichier d'interface est enregistré dans un fichier se terminant par .java et le nom du fichier utilise le nom de l'interface.
Le fichier bytecode de l'interface est enregistré dans un fichier se terminant par .class.
Les fichiers de bytecode correspondants pour l'interface doivent se trouver dans une structure de répertoires qui correspond au nom du package.

La différence entre interface et classe :

Les interfaces ne peuvent pas être utilisées pour instancier des objets.
L'interface n'a pas de méthode constructeur.
Toutes les méthodes de l'interface doivent être des méthodes abstraites.
Les interfaces ne peuvent pas contenir de variables membres, à l'exception des variables statiques et finales.
L'interface n'est pas héritée par la classe, mais implémentée par la classe.
Les interfaces prennent en charge l'héritage multiple.

Déclaration d'interface

La syntaxe de déclaration de l'interface est la suivante :

[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}

Le mot-clé Interface permet de déclarer une interface . Vous trouverez ci-dessous un exemple simple de déclaration d'interface. L'interface

/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包

public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

présente les caractéristiques suivantes :

Les interfaces sont implicitement abstraites. Lors de la déclaration d'une interface, vous n'avez pas besoin d'utiliser le mot-clé abstract.
Chaque méthode de l'interface est également implicitement abstraite et ne nécessite pas le mot-clé abstract lors de sa déclaration.
Toutes les méthodes de l'interface sont publiques.

Instance

/* 文件名 : Animal.java */
interface Animal {

   public void eat();
   public void travel();
}

Implémentation de l'interface

Lorsqu'une classe implémente une interface, la classe doit implémenter toutes les méthodes de l'interface. Sinon, la classe doit être déclarée abstraite. La classe

utilise le mot-clé Implements pour implémenter l'interface. Dans une déclaration de classe, le mot clé Implements est placé après la déclaration de classe.

Pour implémenter la syntaxe d'une interface, vous pouvez utiliser cette formule :

... implements 接口名称[, 其他接口, 其他接口..., ...] ...

Exemple

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{

   public void eat(){
      System.out.println("Mammal eats");
   }

   public void travel(){
      System.out.println("Mammal travels");
   } 

   public int noOfLegs(){
      return 0;
   }

   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

Mammal eats
Mammal travels

Réécrivez l'interface Lors de la déclaration des méthodes, vous devez faire attention aux règles suivantes :

Lorsqu'une classe implémente une méthode d'interface, elle ne peut pas lever d'exception obligatoire. Elle ne peut lever l'exception obligatoire que dans l'interface ou dans une classe abstraite qui hérite de l'interface.
Les classes doivent conserver des noms de méthode cohérents lors du remplacement des méthodes et doivent conserver des types de valeurs de retour identiques ou compatibles.
Si la classe qui implémente l’interface est une classe abstraite, il n’est pas nécessaire d’implémenter les méthodes de l’interface.

Lors de la mise en œuvre de l'interface, vous devez également faire attention à certaines règles :

Une classe peut implémenter plusieurs interfaces en même temps.
Une classe ne peut hériter que d’une seule classe, mais peut implémenter plusieurs interfaces.
Une interface peut hériter d’une autre interface, ce qui est similaire à l’héritage entre classes.

Héritage des interfaces

Une interface peut hériter d'une autre interface, ce qui est similaire à la méthode d'héritage entre classes. L'héritage d'interface utilise le mot-clé extends et les sous-interfaces héritent des méthodes de l'interface parent.

L'interface Sports suivante est héritée des interfaces Hockey et Football :

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

L'interface Hockey déclare quatre méthodes qui lui sont propres et hérite de deux méthodes du Interface sportive , De cette façon, la classe qui implémente l'interface Hockey doit implémenter six méthodes.

De même, une classe qui implémente l'interface Football doit implémenter cinq méthodes, dont deux proviennent de l'interface Sports.

Héritage multiple d'interfaces

En Java, l'héritage multiple de classes est illégal, mais les interfaces autorisent l'héritage multiple.

Dans l'héritage multiple d'interfaces, le mot-clé extends ne doit être utilisé qu'une seule fois, suivi de l'interface héritée. Comme indiqué ci-dessous :

public interface Hockey extends Sports, Event

Le fragment de programme ci-dessus est une sous-interface légalement définie. Contrairement aux classes, les interfaces permettent un héritage multiple, et Sports et Event peuvent définir ou hériter de la même méthode

<🎜. >Marquer l'interface

L'interface héritée la plus couramment utilisée est l'interface qui ne contient aucune méthode.

L'interface d'identification est une interface sans aucune méthode ni propriété. Elle indique uniquement que sa classe appartient à un type spécifique pour qu'un autre code puisse tester et permettre de faire quelque chose.

La fonction de l'interface d'identification : Pour faire simple et vivant, il s'agit de marquer (tamponner) un objet afin que l'objet ait certains ou certains privilèges.

Par exemple : L'interface java.util.EventListener héritée par l'interface MouseListener dans le package java.awt.event est définie comme suit :

package java.util;
public interface EventListener
{}

Une interface sans aucune méthode est appelée un marqueur interface. Les interfaces Marker sont principalement utilisées dans les deux buts suivants :

Établir une interface parent publique :
Tout comme l'interface EventListener, qui est composée de dizaines Une API Java qui étend d'autres interfaces. Vous pouvez utiliser une interface balisée pour créer une interface parent pour un groupe d'interfaces. Par exemple : lorsqu'une interface hérite de l'interface EventListener, la machine virtuelle Java (JVM) sait que l'interface sera utilisée pour un schéma de proxy d'événement.
Ajouter un type de données à une classe :
Cette situation est le but initial de l'interface des marqueurs. pas besoin de définir de méthodes d'interface (car les interfaces marquées n'ont aucune méthode), mais la classe devient un type d'interface grâce au polymorphisme.