Interface Java (avec exemples)

Table des matières

Implémentation d'une interface
Extension d'une interface
Avantages de l'interface en Java
méthodes par défaut dans les interfaces Java
private and static Methods in Interface

Dans ce didacticiel, nous allons découvrir les interfaces Java. Nous apprendrons comment implémenter des interfaces et quand les utiliser en détail à l'aide d'exemples.

Une interface est une classe entièrement abstraite qui comprend un groupe de méthodes sans corps.

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

 interface Language ( public void getName(); )

Ici, nous avons utilisé le interfacemot - clé pour créer une interface nommée Language. L'interface Language définit une spécification getName().

Désormais, chaque classe qui utilise cette interface doit implémenter la getName()spécification.

Exemple: interface Java

 // create an interface interface Language ( void getName(String name); ) // class implements interface class ProgrammingLanguage implements Language ( // implementation of abstract method public void getName(String name) ( System.out.println("Programming Language: " + name); ) ) class Main ( public static void main(String() args) ( ProgrammingLanguage language = new ProgrammingLanguage(); language.getName("Java"); ) )

Production

 Langage de programmation: Java

Dans l'exemple ci-dessus, nous avons créé une interface nommée Language. L'interface comprend une méthode abstraite getName().

Ici, la classe ProgrammingLanguage implémente l'interface et fournit l'implémentation de la méthode.

Il n'est pas obligatoire d'utiliser un abstractmot-clé lors de la déclaration de méthodes abstraites dans une interface. C'est parce qu'une interface n'inclut que des méthodes abstraites et non des méthodes régulières.

Remarque : toutes les méthodes à l'intérieur d'une interface sont implicitement publicet tous les champs sont implicitement public static final. Par exemple,

 interface Language ( // by default public static final String type = "programming language"; // by default public void getName(); )

Implémentation d'une interface

Comme les classes abstraites, nous ne pouvons pas créer d'objets d'une interface. Cependant, nous pouvons implémenter une interface.

Nous utilisons le implementsmot - clé pour implémenter une interface. Par exemple,

 // create an interface interface Polygon ( void getArea(int length, int breadth); ) // implement the Polygon interface class Rectangle implements Polygon ( // implementation of abstract method public void getArea(int length, int breadth) ( System.out.println("The area of the rectangle is " + (length * breadth)); ) ) class Main ( public static void main(String() args) ( // create an object Rectangle r1 = new Rectangle(); r1.getArea(5, 6); ) )

Production

 L'aire du rectangle est de 30

Dans l'exemple ci-dessus, nous avons créé une interface nommée Polygon. L'interface contient une méthode abstraite getArea().

Ici, la classe Rectangle implémente Polygon. Et, fournit la mise en œuvre de la getArea()méthode.

Remarque : une classe peut implémenter plusieurs interfaces. Par exemple,

 interface A ( // members of A ) interface B ( // members of B ) class C implements A, B ( // abstract members of A // abstract members of B )

Extension d'une interface

À l'instar des classes, les interfaces peuvent étendre d'autres interfaces. Le extendsmot-clé est utilisé pour étendre les interfaces. Par exemple,

 interface Line ( // members of Line interface ) // extending interface interface Polygon extends Line ( // members of Polygon interface // members of Line interface )

Ici, l'interface Polygon étend l'interface Line. Maintenant, si une classe implémente Polygon, elle devrait fournir des implémentations pour toutes les méthodes abstraites de Line et Polygon.

Remarque : une interface peut étendre plusieurs interfaces. Par exemple,

 interface A (… ) interface B (… ) interface C extends A, B (… )

Avantages de l'interface en Java

Maintenant que nous savons ce que sont les interfaces, apprenons pourquoi les interfaces sont utilisées en Java.

Les interfaces fournissent des spécifications qu'une classe (qui l'implémente) doit suivre.
Dans notre exemple précédent, nous avons utilisé getArea()comme spécification à l'intérieur de l'interface Polygon. C'est comme définir une règle selon laquelle nous devrions être en mesure d'obtenir l'aire de chaque polygone.
Désormais, toute classe qui implémente l'interface Polygon doit fournir une implémentation pour la getArea()méthode.
Semblables aux classes abstraites, les interfaces nous aident à réaliser l' abstraction en Java .
Ici, nous savons que getArea()calcule l'aire des polygones, mais la façon dont l'aire est calculée est différente pour différents polygones. Par conséquent, la mise en œuvre de getArea()est indépendante l'une de l'autre.
Les interfaces sont également utilisées pour obtenir un héritage multiple en Java. Par exemple,
```
 interface Line (… ) interface Polygon (… ) class Rectangle implements Line, Polygon (… )
```
Ici, la classe Rectangle implémente deux interfaces différentes. C'est ainsi que nous réalisons l'héritage multiple en Java.

méthodes par défaut dans les interfaces Java

Avec la sortie de Java 8, nous pouvons désormais ajouter des méthodes avec implémentation dans une interface. Ces méthodes sont appelées méthodes par défaut.

Pour déclarer les méthodes par défaut dans les interfaces, nous utilisons le defaultmot - clé. Par exemple,

 public default void getSides() ( // body of getSides() )

Pourquoi les méthodes par défaut?

Let's take a scenario to understand why default methods are introduced in Java.

Suppose, we need to add a new method in an interface.

We can add the method in our interface easily without implementation. However, that's not the end of the story. All our classes that implement that interface must provide an implementation for the method.

If a large number of classes were implementing this interface, we need to track all these classes and make changes in them. This is not only tedious but error-prone as well.

To resolve this, Java introduced default methods. Default methods are inherited like ordinary methods.

Let's take an example to have a better understanding of default methods.

Example: Default Method in Java Interface

 interface Polygon ( void getArea(); // default method default void getSides() ( System.out.println("I can get sides of a polygon."); ) ) // implements the interface class Rectangle implements Polygon ( public void getArea() ( int length = 6; int breadth = 5; int area = length * breadth; System.out.println("The area of the rectangle is " + area); ) // overrides the getSides() public void getSides() ( System.out.println("I have 4 sides."); ) ) // implements the interface class Square implements Polygon ( public void getArea() ( int length = 5; int area = length * length; System.out.println("The area of the square is " + area); ) ) class Main ( public static void main(String() args) ( // create an object of Rectangle Rectangle r1 = new Rectangle(); r1.getArea(); r1.getSides(); // create an object of Square Square s1 = new Square(); s1.getArea(); s1.getSides(); ) )

Output

 The area of the rectangle is 30 I have 4 sides. The area of the square is 25 I can get sides of a polygon.

In the above example, we have created an interface named Polygon. It has a default method getSides() and an abstract method getArea().

Here, we have created two classes Rectangle and Square that implement Polygon.

The Rectangle class provides the implementation of the getArea() method and overrides the getSides() method. However, the Square class only provides the implementation of the getArea() method.

Now, while calling the getSides() method using the Rectangle object, the overridden method is called. However, in the case of the Square object, the default method is called.

private and static Methods in Interface

The Java 8 also added another feature to include static methods inside an interface.

Similar to a class, we can access static methods of an interface using its references. For example,

 // create an interface interface Polygon ( staticMethod()(… ) ) // access static method Polygon.staticMethod();

Note: With the release of Java 9, private methods are also supported in interfaces.

We cannot create objects of an interface. Hence, private methods are used as helper methods that provide support to other methods in interfaces.

Practical Example of Interface

Let's see a more practical example of Java Interface.

 // To use the sqrt function import java.lang.Math; interface Polygon ( void getArea(); // calculate the perimeter of a Polygon default void getPerimeter(int… sides) ( int perimeter = 0; for (int side: sides) ( perimeter += side; ) System.out.println("Perimeter: " + perimeter); ) ) class Triangle implements Polygon ( private int a, b, c; private double s, area; // initializing sides of a triangle Triangle(int a, int b, int c) ( this.a = a; this.b = b; this.c = c; s = 0; ) // calculate the area of a triangle public void getArea() ( s = (double) (a + b + c)/2; area = Math.sqrt(s*(s-a)*(s-b)*(s-c)); System.out.println("Area: " + area); ) ) class Main ( public static void main(String() args) ( Triangle t1 = new Triangle(2, 3, 4); // calls the method of the Triangle class t1.getArea(); // calls the method of Polygon t1.getPerimeter(2, 3, 4); ) )

Output