InterfaceJava
Interface Java
Dans ce tutoriel, 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. Il comprend un groupe de méthodes abstraites (méthodes sans corps).
Nous utilisons le interface mot-clé pour créer une interface en Java. Par exemple,
interface Language {
public void getType();
public void getVersion();
} Ici,
- Langue est une interface.
- Il inclut des méthodes abstraites :
getType()etgetVersion().
Implémentation d'une interface
Comme les classes abstraites, nous ne pouvons pas créer d'objets d'interfaces.
Pour utiliser une interface, d'autres classes doivent l'implémenter. Nous utilisons le implements mot-clé pour implémenter une interface.
Exemple 1 :interface Java
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) {
Rectangle r1 = new Rectangle();
r1.getArea(5, 6);
}
} Sortie
The area of the rectangle is 30
Dans l'exemple ci-dessus, nous avons créé une interface nommée Polygon . L'interface contient une méthode abstraite getArea() .
Ici, le Rectangle la classe implémente Polygon . Et, fournit l'implémentation du getArea() méthode.
Exemple 2 :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");
}
} Sortie
Programming Language: Java
Dans l'exemple ci-dessus, nous avons créé une interface nommée Language . L'interface comprend une méthode abstraite getName() .
Ici, le ProgrammingLanguage classe implémente l'interface et fournit l'implémentation de la méthode.
Mise en œuvre de plusieurs interfaces
En Java, une classe peut également 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
} Étendre une interface
Semblables aux classes, les interfaces peuvent étendre d'autres interfaces. Le extends mot 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, le polygone l'interface étend la Ligne interface. Maintenant, si une classe implémente Polygon , il devrait fournir des implémentations pour toutes les méthodes abstraites de Line et Polygone .
Étendre plusieurs interfaces
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, découvrons pourquoi les interfaces sont utilisées en Java.
- Semblable aux classes abstraites, les interfaces nous aident à réaliser l'abstraction en Java .
Ici, on connaîtgetArea()calcule la surface des polygones mais la façon dont la surface est calculée est différente pour différents polygones. D'où l'implémentation degetArea()sont indépendants les uns des autres. - 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 établir une règle selon laquelle nous devrions pouvoir obtenir l'aire de chaque polygone.
Désormais, toute classe qui implémente le Polygon l'interface doit fournir une implémentation pour legetArea()méthode. - 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.
Remarque :Toutes les méthodes à l'intérieur d'une interface sont implicitement public et 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();
} 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 à l'intérieur des interfaces, nous utilisons le default mot-clé. Par exemple,
public default void getSides() {
// body of getSides()
} Pourquoi les méthodes par défaut ?
Prenons un scénario pour comprendre pourquoi les méthodes par défaut sont introduites en Java.
Supposons que nous ayons besoin d'ajouter une nouvelle méthode dans une interface.
Nous pouvons facilement ajouter la méthode dans notre interface sans implémentation. Cependant, ce n'est pas la fin de l'histoire. Toutes nos classes qui implémentent cette interface doivent fournir une implémentation pour la méthode.
Si un grand nombre de classes implémentaient cette interface, nous devons suivre toutes ces classes et y apporter des modifications. Ce n'est pas seulement fastidieux, mais aussi source d'erreurs.
Pour résoudre ce problème, Java a introduit des méthodes par défaut. Les méthodes par défaut sont héritées comme les méthodes ordinaires.
Prenons un exemple pour mieux comprendre les méthodes par défaut.
Exemple :méthode par défaut dans l'interface Java
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();
}
} Sortie
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.
Dans l'exemple ci-dessus, nous avons créé une interface nommée Polygon . Il a une méthode par défaut getSides() et une méthode abstraite getArea() .
Ici, nous avons créé deux classes Rectangle et Carré qui implémentent Polygon .
Le rectangle la classe fournit l'implémentation du getArea() méthode et remplace le getSides() méthode. Cependant, le Carré la classe ne fournit que l'implémentation du getArea() méthode.
Maintenant, en appelant le getSides() méthode utilisant le Rectangle objet, la méthode surchargée est appelée. Cependant, dans le cas du Carré objet, la méthode par défaut est appelée.
Méthodes privées et statiques dans l'interface
Le Java 8 a également ajouté une autre fonctionnalité pour inclure des méthodes statiques dans une interface.
Semblable à une classe, nous pouvons accéder aux méthodes statiques d'une interface en utilisant ses références. Par exemple,
// create an interface
interface Polygon {
staticMethod(){..}
}
// access static method
Polygon.staticMethod(); Remarque :Avec la version de Java 9, les méthodes privées sont également prises en charge dans les interfaces.
On ne peut pas créer les objets d'une interface. Par conséquent, les méthodes privées sont utilisées comme méthodes d'assistance qui fournissent un support à d'autres méthodes dans les interfaces.
Exemple pratique d'interface
Voyons un exemple plus pratique d'interface Java.
// 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);
}
} Sortie
Area: 2.9047375096555625 Perimeter: 9
Dans le programme ci-dessus, nous avons créé une interface nommée Polygon . Il inclut une méthode par défaut getPerimeter() et une méthode abstraite getArea() .
Nous pouvons calculer le périmètre de tous les polygones de la même manière, nous avons donc implémenté le corps de getPerimeter() dans Polygone .
Désormais, tous les polygones qui implémentent Polygon peut utiliser getPerimeter() pour calculer le périmètre.
Cependant, la règle de calcul de la surface est différente pour différents polygones. Par conséquent, getArea() est inclus sans implémentation.
Toute classe qui implémente Polygon doit fournir une implémentation de getArea() .
Java