Interfaces Java

1. Vue d'ensemble

Dans ce tutoriel, nous allons parler des interfaces en Java. Nous verrons également comment Java les utilise pour implémenter le polymorphisme et les héritages multiples.

2. Que sont les interfaces en Java?

En Java, une interface est un type abstrait qui contient une collection de méthodes et de variables constantes. C'est l'un des concepts de base de Java et est utilisé pour réaliser l'abstraction, le polymorphisme et les héritages multiples .

Voyons un exemple simple d'interface en Java:

public interface Electronic { // Constant variable String LED = "LED"; // Abstract method int getElectricityUse(); // Static method static boolean isEnergyEfficient(String electtronicType) { if (electtronicType.equals(LED)) { return true; } return false; } //Default method default void printDescription() { System.out.println("Electronic Description"); } } 

Nous pouvons implémenter une interface dans une classe Java en utilisant le mot clé implements .

Ensuite, créons également une classe Computer qui implémente l' interface électronique que nous venons de créer:

public class Computer implements Electronic { @Override public int getElectricityUse() { return 1000; } } 

2.1. Règles de création d'interfaces

Dans une interface, nous sommes autorisés à utiliser:

  • variables constantes
  • méthodes abstraites
  • méthodes statiques
  • méthodes par défaut

Nous devons également nous rappeler que:

  • nous ne pouvons pas instancier directement les interfaces
  • une interface peut être vide, sans méthode ni variable
  • nous ne pouvons pas utiliser le dernier mot dans la définition de l'interface, car cela entraînera une erreur du compilateur
  • toutes les déclarations d'interface doivent avoir le modificateur d'accès public ou par défaut; le modificateur abstrait sera ajouté automatiquement par le compilateur
  • une méthode d'interface ne peut pas être privée , protégée ou définitive
  • les variables d'interface sont publiques , statiques et finales par définition; nous n'avons pas le droit de changer leur visibilité

3. Que pouvons-nous réaliser en les utilisant?

3.1. Fonctionnalité comportementale

Nous utilisons des interfaces pour ajouter certaines fonctionnalités comportementales qui peuvent être utilisées par des classes non liées. Par exemple, Comparable , Comparator et Cloneable sont des interfaces Java qui peuvent être implémentées par des classes non liées. Voici un exemple de l' interface du comparateurqui est utilisé pour comparer deux instances de la classe Employee :

public class Employee { private double salary; public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } } public class EmployeeSalaryComparator implements Comparator { @Override public int compare(Employee employeeA, Employee employeeB) { if (employeeA.getSalary()  employeeB.getSalary()) { return 1; } else { return 0; } } } 

Pour plus d'informations, veuillez visiter notre tutoriel sur Comparator et Comparable en Java.

3.2. Héritages multiples

Les classes Java prennent en charge l'héritage singulier. Cependant, en utilisant des interfaces, nous pouvons également implémenter plusieurs héritages.

Par exemple, dans l'exemple ci-dessous, nous remarquons que la classe Carimplémente les interfaces Fly et Transform . Ce faisant, il hérite des méthodes fly et transformer :

public interface Transform { void transform(); } public interface Fly { void fly(); } public class Car implements Fly, Transform { @Override public void fly() { System.out.println("I can Fly!!"); } @Override public void transform() { System.out.println("I can Transform!!"); } } 

3.3. Polymorphisme

Commençons par poser la question: qu'est-ce que le polymorphisme? C'est la possibilité pour un objet de prendre différentes formes pendant l'exécution. Pour être plus précis, c'est l'exécution de la méthode de substitution qui est liée à un type d'objet spécifique au moment de l'exécution.

En Java, nous pouvons réaliser un polymorphisme à l'aide d'interfaces. Par exemple, l' interface Forme peut prendre différentes formes - il peut s'agir d'un cercle ou d'un carré.

Commençons par définir l' interface Shape :

public interface Shape { String name(); } 

Maintenant, créons également la classe Circle :

public class Circle implements Shape { @Override public String name() { return "Circle"; } } 

Et aussi la classe Square :

public class Square implements Shape { @Override public String name() { return "Square"; } } 

Enfin, il est temps de voir le polymorphisme en action à l'aide de notre interface Shape et de ses implémentations. Allons instancier quelques Shape objets, les ajouter à une liste , et, enfin, imprimer leurs noms dans une boucle:

List shapes = new ArrayList(); Shape circleShape = new Circle(); Shape squareShape = new Square(); shapes.add(circleShape); shapes.add(squareShape); for (Shape shape : shapes) { System.out.println(shape.name()); } 

4. Méthodes par défaut dans les interfaces

Les interfaces traditionnelles de Java 7 et inférieurs n'offrent pas de compatibilité descendante.

What this means is that if you have legacy code written in Java 7 or earlier, and you decide to add an abstract method to an existing interface, then all the classes that implement that interface must override the new abstract method. Otherwise, the code will break.

Java 8 solved this problem by introducing the default method that is optional and can be implemented at the interface level.

5. Interface Inheritance Rules

In order to achieve multiple inheritances thru interfaces, we have to remember a few rules. Let's go over these in detail.

5.1. Interface Extending Another Interface

When an interface extends another interface, it inherits all of that interface's abstract methods. Let's start by creating two interfaces, HasColor and Shape:

public interface HasColor { String getColor(); } public interface Box extends HasColor { int getHeight() } 

In the example above, Box inherits from HasColor using the keyword extends. By doing so, the Box interface inherits getColor. As a result, the Box interface now has two methods: getColor and getHeight.

5.2. Abstract Class Implementing an Interface

When an abstract class implements an interface, it inherits all of its abstract and default methods. Let's consider the Transform interface and the abstract class Vehicle that implements it:

public interface Transform { void transform(); default void printSpecs(){ System.out.println("Transform Specification"); } } public abstract class Vehicle implements Transform {} 

In this example, the Vehicle class inherits two methods: the abstract transform method and the default printSpecs method.

6. Functional Interfaces

Java has had many functional interfaces since its early days, such as Comparable (since Java 1.2) and Runnable (since Java 1.0).

Java 8 a introduit de nouvelles interfaces fonctionnelles telles que Predicate , Consumer et Function . Pour en savoir plus à ce sujet, veuillez consulter notre didacticiel sur les interfaces fonctionnelles dans Java 8.

7. Conclusion

Dans ce didacticiel, nous avons donné un aperçu des interfaces Java et nous avons expliqué comment les utiliser pour obtenir un polymorphisme et des héritages multiples.

Comme toujours, les exemples de code complets sont disponibles à l'adresse over sur GitHub.