Interface (Interface) Java

Dans ce tutoriel, nous allons apprendre Java interface. Nous allons apprendre à implémenter une interface et quand les utiliser à l'aide d'exemples.

En Java, une interface définit un ensemble de normes que d'autres classes doivent implémenter. Par exemple,

interface Polygon {
　　　public void getArea();
}

Ici, Polygon est une interface. Nous avons utilisé la clé interface pour déclarer une interface.

La méthode getArea() est définie comme une norme dans l'interface Polygon. Tous les classes utilisant cette interface doivent implémenter la méthode getArea().

Une interface peut inclure des méthodes abstraites et des constantes. Par exemple,

interface Polygon {
　　　public static final String color = "blue";
　　　
　　　public void getArea();
}

Dans l'exemple ci-dessus, nous avons créé une interface Polygon. Elle comprend une variable constante color et une méthode abstraite getArea().

Il est important de noter que toutes les méthodes dans l'interface sont implicitement public, et tous les champs sont implicitement public static final. Par conséquent, il n'est pas nécessaire de spécifier les modificateurs d'accès à l'intérieur de l'interface. Par exemple, nous pouvons écrire le code ci-dessus de la manière suivante

interface Polygon {
　　　String couleur = "bleu";
　　　
　　　　void getArea();
}

Interface et mot-clé implements

Comme pour une classe abstraite, nous ne pouvons pas créer d'objet d'interface. Cependant, nous pouvons l'implémenter dans d'autres classes. En Java, nous utilisons le mot-clé implements pour implémenter une interface. Par exemple,

interface Polygon {
　　　　void getArea(int longueur, int largeur);
}
class Rectangle implements Polygon {
　　　　public void getArea(int longueur, int largeur) {
　　　　　　　　System.out.println("L'aire du rectangle est "　+　(longueur　*　largeur));
　　　　}
}
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　Rectangle r1　= new Rectangle();
　　　　　　　　r1.getArea(5,　6);
　　　　}
}

Résultat de la sortie

L'aire du rectangle est　30

Dans le programme ci-dessus, nous avons créé une interface Polygon. L'interface Polygon possède une méthode abstraite getArea().

　Cela signifie que toute classe implémentant Polygon doit fournir une implémentation pour la méthode getArea().

Notez que la classe Rectangle (implémentant l'interface Polygon) a une méthode implémentée getArea().

Pourquoi utiliser une interface ?

Maintenant que nous savons ce qu'est une interface, nous allons comprendre pourquoi elle est utilisée en Java.

• Les interfaces fournissent des spécifications que les classes (qui les implémentent) doivent suivre.

• Dans l'exemple ci-dessus, nous avons utilisé getArea() comme une spécification dans l'interface Polygon. Cela ressemble à établir une règle, à savoir que nous devrions pouvoir obtenir la surface de chaque polygone. Par conséquent, toute classe implémentant l'interface Polygon doit fournir l'implémentation de la méthode getArea().

• Comme pour une classe abstraite, une interface peut nous aider à réaliser l'abstraction en Java. Ici, nous savons que getArea() calcule la surface d'un polygone, mais pour différents polygones, la méthode de calcul de la surface est différente. Par conséquent, les implémentations de getArea() sont indépendantes les unes des autres.

• Les interfaces sont également utilisées pour réaliser la surcharge multiple en Java. Si une sous-classe hérite de deux ou plusieurs classes, c'est une surcharge multiple.

  En Java, il n'est pas possible de réaliser la surcharge multiple en héritant d'une classe. Cependant, une classe peut réaliser plusieurs interfaces. Cela nous permet d'obtenir la fonctionnalité de surcharge multiple en Java. Par exemple,

  interface Line {
  　　　...
  }
  interface Polygon {
  　　　...
  }
  class Rectangle implements Line, Polygon{
  　　　...
  }

  Ici, Rectangle doit fournir l'implémentation de toutes les méthodes de Line et Polygon.

Les méthodes privées et statiques de l'interface

Java 8dans laquelle l'interface peut maintenant inclure des méthodes statiques.

Comme pour une classe, nous pouvons utiliser une référence pour accéder aux méthodes statiques de l'interface. Par exemple,

Polygon.staticMethod();

De plus, dans Java, l'interface 9La version publiée prend en charge les méthodes privées. Maintenant, vous pouvez utiliserMéthode privéeetMéthode statique privée。

Comme les interfaces ne peuvent pas être instanciées, les méthodes privées sont utilisées comme méthodes d'aide pour fournir un soutien aux autres méthodes de l'interface.

méthodes par défaut dans les interfaces

Java 8dans lequel une méthode avec une implémentation a été introduite dans l'interface (méthode par défaut). Avant cela, toutes les méthodes étaient des méthodes abstraites en Java.

Pour déclarer une méthode par défaut dans une interface, nous utilisons le mot-clé default. Par exemple,

public default void getSides() {
　　　//Corps de la méthode getSides()
}

Pourquoi utiliser les méthodes par défaut ?

Laissons-nous prendre un scénario pour comprendre pourquoi Java a introduit les méthodes par défaut.

Supposons que nous devions ajouter une nouvelle méthode à l'interface.

Nous pouvons facilement ajouter cette méthode à l'interface sans l'exécuter. Mais ce n'est pas la fin de l'histoire. Tous les classes qui implémentent cette interface doivent fournir l'implémentation de cette méthode.

Si de nombreux classes sont en train d'implémenter cet interface, nous devons suivre toutes ces classes et les modifier. Cela est non seulement fastidieux, mais aussi sujet aux erreurs.

Pour résoudre ce problème, Java a introduit les méthodes par défaut. Les méthodes par défaut héritent comme les méthodes normales.

Laissons-nous prendre un exemple pour mieux comprendre la méthode par défaut.

Exemple2：méthode par défaut

interface Polygon {
　　　void getArea();
　　　default void getSides() {
　　　　　　System.out.println("Je peux obtenir les côtés du polygone.");
　　　}
}
class Rectangle implements Polygon {
　　　public void getArea() {
　　　　　　int length =　6;
　　　　　　int largeur =　5;
　　　　　　int area = length　*　largeur;
　　　　　　System.out.println("L'aire du rectangle est "+area);
　　　}
　　　public void getSides() {
　　　　　　System.out.println("J'ai quatre côtés.");
　　　}
}
class Square implements Polygon {
　　　public void getArea() {
　　　　　　int length =　5;
　　　　　　int area = length　*　length;
　　　　　　System.out.println("L'aire du carré est "+area);
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Rectangle r1　= new Rectangle();
　　　　　　r1.getArea();
　　　　　　r1.getSides();
　　　　　　Square s1　= new Square();
　　　　　　s1.getArea();
　　　}
}

Résultat de la sortie

L'aire du rectangle est　30
J'ai quatre côtés.
L'aire du carré est　25

Dans l'exemple ci-dessus, nous avons créé une interface Polygon. Polygon possède une méthode par défaut getSides() et une méthode abstraite getArea().

Ensuite, la classe Rectangle implémente Polygon, Rectangle fournit l'implémentation de la méthode abstraite getArea() et surcharge la méthode par défaut getSides().

Nous avons créé une autre classe Square, qui implémente également Polygon. Ici, Square ne fournit que l'implémentation de la méthode abstraite getArea().

Exemple d'application réelle de l'interface

Voyons un exemple plus pratique d'interface Java.

//Utiliser la fonction sqrt
import java.lang.Math;
interface Polygon {
　　　void getArea();
　　
　　　　　//Calculer la longueur de périmètre du polygone
　　　default void getPerimeter(int... sides) {
　　　　　　int perimeter = 0;
　　　　　　for (int side : sides) {
　　　　　　　　　perimeter　+= side;
　　　　　　}
　　　System.out.println("Longueur de périmètre: "　+　perimeter);
　　　}
}
class Triangle implements Polygon {
　　　private int a, b, c;
　　　private double s, area;
　　　　//Initialiser les côtés du triangle
　　　Triangle(int a, int b, int c) {
　　　　　　this.a = a;
　　　　　　this.b = b;
　　　　　　this.c = c;
　　　　　　s = 0;
　　　}
　　　　//Calculer la surface du triangle
　　　public void getArea() {
　　　　　　s = (double) (a　+　b　+　c)/2;
　　　　　　area = Math.sqrt(s*(s-a)*(s-b)*(s-c));
　　　　　　System.out.println("Surface: "　+　area);
　　　}
}
class Main {
　　　public static void main(String[] args) {
　　　　　　Triangle t1　= new Triangle(2,　3,　4);
　　　　　　//Appel de la méthode de la classe Triangle
　　　　　　t1.getArea();
　　　　　　//Appel de la méthode de la classe Polygon
　　　　　　t1.getPerimeter(2,　3,　4);
　　　}
}

Résultat de la sortie

Surface:　2.9047375096555625
Longueur de périmètre:　9

Dans le programme ci-dessus, nous avons créé une interface Polygon. Elle inclut la méthode par défaut getParameter() et la méthode abstraite getArea().

Nous pouvons calculer la longueur de périmètre de tous les polygones de la même manière, donc nous avons implémenté le corps de getPerimeter() dans Polygon. Tous les polygones implémentant Polygon peuvent utiliser getPerimeter() pour calculer la longueur de périmètre.

Cependant, la méthode de calcul de l'aire est différente pour les polygones différents, car les règles de calcul de l'aire sont différentes pour les polygones différents.

Par conséquent, il n'y a pas d'implémentation dans Polygon mais contient getArea(). Et toute classe implémentant l'interface Polygon doit fournir une implémentation de getArea().

Interface et le mot-clé extends

Comme pour les classes, les interfaces peuvent hériter d'autres interfaces, l'opérateur extends est utilisé pour hériter d'interfaces. Par exemple,

interface Line {
　　　//Membres de l'interface Line
}
interface Polygon extends Line {
　　　//Membres de l'interface Polygon et de l'interface Line
}

Dans l'exemple ci-dessus, l'interface Polygon hérite de l'interface Line. Maintenant, si une classe implémente Polygon, elle doit fournir des implémentations pour toutes les classes abstraites de Line et Polygon.

Attention, une interface peut hériter de plusieurs interfaces, de la même manière qu'une classe implémentant plusieurs interfaces.

interface A {
　　　...
}
interface B {
　　　...　
}
Interface C extends A, B {
　　　...
}