Un Interface en Java Le langage de programmation est défini comme un type abstrait utilisé pour spécifier le comportement d'une classe. Une interface en Java est un modèle de comportement. Une interface Java contient des constantes statiques et des méthodes abstraites.

Que sont les interfaces en Java ?

L'interface en Java est un mécanisme pour atteindre abstraction . Il ne peut y avoir que des méthodes abstraites dans l'interface Java, pas le corps de la méthode. Il est utilisé pour réaliser l'abstraction et plusieurs héritages en Java en utilisant l'interface . En d’autres termes, on peut dire que les interfaces peuvent avoir des méthodes et des variables abstraites. Il ne peut pas avoir de corps de méthode. Interface Java également représente la relation IS-A .

Lorsque nous décidons d'un type d'entité par son comportement et non via un attribut, nous devons le définir comme une interface.

Syntaxe pour les interfaces Java

interface {  // declare constant fields  // declare methods that abstract   // by default.  }>

Pour déclarer une interface, utilisez le mot-clé interface. Il est utilisé pour fournir une abstraction totale. Cela signifie que toutes les méthodes d'une interface sont déclarées avec un corps vide et sont publiques et que tous les champs sont publics, statiques et finaux par défaut. Une classe qui implémente une interface doit implémenter toutes les méthodes déclarées dans l'interface. Pour implémenter l'interface, utilisez le mot-clé Implements.

Utilisations des interfaces en Java

Les utilisations des interfaces en Java sont mentionnées ci-dessous :

• Il est utilisé pour parvenir à une abstraction totale.
• Étant donné que Java ne prend pas en charge plusieurs héritages dans le cas d'une classe, en utilisant une interface, il peut réaliser plusieurs héritages.
• N'importe quelle classe ne peut étendre qu'une seule classe, mais n'importe quelle classe peut-elle implémenter un nombre infini d'interfaces.
• Il est également utilisé pour obtenir un couplage lâche.
• Les interfaces sont utilisées pour implémenter l'abstraction.

Alors, la question se pose, pourquoi utiliser des interfaces alors que nous avons des classes abstraites ?

La raison en est que les classes abstraites peuvent contenir des variables non finales, alors que les variables de l'interface sont finales, publiques et statiques.

// A simple interface interface Player {  final int id = 10;  int move(); }>

Relation entre la classe et l'interface

Une classe peut étendre une autre classe similaire à celle-ci, une interface peut étendre une autre interface. Mais seule une classe peut s'étendre à une autre interface, et l'inverse n'est pas autorisé.

Différence entre classe et interface

Bien que la classe et l'interface semblent identiques, il existe certaines différences entre les classes et l'interface. Les principales différences entre une classe et une interface sont mentionnées ci-dessous :

Mise en œuvre: Pour implémenter une interface, nous utilisons le mot-clé met en oeuvre

// Java program to demonstrate working of // interface import java.io.*; // A simple interface interface In1 {    // public, static and final  final int a = 10;  // public and abstract  void display(); } // A class that implements the interface. class TestClass implements In1 {    // Implementing the capabilities of  // interface.  public void display(){   System.out.println('Geek');   }  // Driver Code  public static void main(String[] args)  {  TestClass t = new TestClass();  t.display();  System.out.println(t.a);  } }>

Geek 10>

Exemples d'interfaces Java

Prenons l'exemple de véhicules comme les vélos, les voitures, les vélos, etc. Ils ont des fonctionnalités communes. Nous réalisons donc une interface et mettons toutes ces fonctionnalités communes. Et laisse Bicycle, Bike, car, etc. implémenter toutes ces fonctionnalités dans leur propre classe à leur manière.

Vous trouverez ci-dessous la mise en œuvre du sujet ci-dessus :

base de données java jdbc

// Java program to demonstrate the  // real-world example of Interfaces import java.io.*; interface Vehicle {    // all are the abstract methods.  void changeGear(int a);  void speedUp(int a);  void applyBrakes(int a); } class Bicycle implements Vehicle{    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  } } class Bike implements Vehicle {    int speed;  int gear;    // to change gear  @Override  public void changeGear(int newGear){    gear = newGear;  }    // to increase speed  @Override  public void speedUp(int increment){    speed = speed + increment;  }    // to decrease speed  @Override  public void applyBrakes(int decrement){    speed = speed - decrement;  }    public void printStates() {  System.out.println('speed: ' + speed  + ' gear: ' + gear);  }   } class GFG {    public static void main (String[] args) {    // creating an instance of Bicycle  // doing some operations  Bicycle bicycle = new Bicycle();  bicycle.changeGear(2);  bicycle.speedUp(3);  bicycle.applyBrakes(1);    System.out.println('Bicycle present state :');  bicycle.printStates();    // creating instance of the bike.  Bike bike = new Bike();  bike.changeGear(1);  bike.speedUp(4);  bike.applyBrakes(3);    System.out.println('Bike present state :');  bike.printStates();  } }>

Bicycle present state : speed: 2 gear: 2 Bike present state : speed: 1 gear: 1>

Avantages des interfaces en Java

Les avantages de l'utilisation d'interfaces en Java sont les suivants :

• Sans nous soucier de la partie mise en œuvre, nous pouvons assurer la sécurité de la mise en œuvre.
• En Java, les héritages multiples ne sont pas autorisés, cependant, vous pouvez utiliser une interface pour l'utiliser car vous pouvez implémenter plusieurs interfaces.

Héritage multiple en Java à l'aide de l'interface

L'héritage multiple est un concept de POO qui ne peut pas être implémenté en Java à l'aide de classes. Mais nous pouvons utiliser plusieurs héritages en Java en utilisant Interface. vérifions cela avec un exemple.

Exemple:

// Java program to demonstrate How Diamond Problem // Is Handled in case of Default Methods // Interface 1 interface API {  // Default method  default void show()  {  // Print statement  System.out.println('Default API');  } } // Interface 2 // Extending the above interface interface Interface1 extends API {  // Abstract method  void display(); } // Interface 3 // Extending the above interface interface Interface2 extends API {  // Abstract method  void print(); } // Main class // Implementation class code class TestClass implements Interface1, Interface2 {  // Overriding the abstract method from Interface1  public void display()  {  System.out.println('Display from Interface1');  }  // Overriding the abstract method from Interface2  public void print()  {  System.out.println('Print from Interface2');  }  // Main driver method  public static void main(String args[])  {  // Creating object of this class  // in main() method  TestClass d = new TestClass();  // Now calling the methods from both the interfaces  d.show(); // Default method from API  d.display(); // Overridden method from Interface1  d.print(); // Overridden method from Interface2  } }>

Default API>

Nouvelles fonctionnalités ajoutées dans les interfaces du JDK 8

Certaines fonctionnalités ont été ajoutées aux interfaces dans la mise à jour JDK 8 mentionnées ci-dessous :

1. Avant JDK 8, l'interface ne pouvait pas définir l'implémentation. Nous pouvons maintenant ajouter une implémentation par défaut pour les méthodes d'interface. Cette implémentation par défaut a une utilisation particulière et n'affecte pas l'intention derrière les interfaces.

Supposons que nous devions ajouter une nouvelle fonction à une interface existante. Évidemment, l’ancien code ne fonctionnera pas car les classes n’ont pas implémenté ces nouvelles fonctions. Ainsi, avec l’aide de l’implémentation par défaut, nous donnerons un corps par défaut pour les fonctions nouvellement ajoutées. Les anciens codes fonctionneront alors toujours.

Vous trouverez ci-dessous la mise en œuvre du point ci-dessus :

// Java program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  default void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  TestClass t = new TestClass();  t.display();  } }>

hello>

2. Une autre fonctionnalité ajoutée dans JDK 8 est que nous pouvons désormais définir des méthodes statiques dans des interfaces qui peuvent être appelées indépendamment sans objet.

Note: ces méthodes ne sont pas héritées.

arbre de recherche binaire

// Java Program to show that interfaces can // have methods from JDK 1.8 onwards interface In1 {  final int a = 10;  static void display()  {  System.out.println('hello');  } } // A class that implements the interface. class TestClass implements In1 {  // Driver Code  public static void main (String[] args)  {  In1.display();  } }>

hello>

Extension des interfaces

Une interface peut en hériter d’une autre en utilisant le mot-clé extends. Lorsqu'une classe implémente une interface qui hérite d'une autre interface, elle doit fournir une implémentation pour toutes les méthodes requises par la chaîne d'héritage d'interface.

Programme 1 :

interface A {  void method1();  void method2(); } // B now includes method1 and method2 interface B extends A {  void method3(); } // the class must implement all method of A and B. class gfg implements B {  public void method1()  {  System.out.println('Method 1');  }  public void method2()  {  System.out.println('Method 2');  }  public void method3()  {  System.out.println('Method 3');  } }>

Programme 2 :

interface Student  {  public void data();   } class avi implements Student {  public void data ()  {  String name='avinash';  int rollno=68;  System.out.println(name);  System.out.println(rollno);  } } public class inter_face  {  public static void main (String args [])  {  avi h= new avi();  h.data();  } }>

avinash 68>

De manière simple, l'interface contient plusieurs méthodes abstraites, alors écrivez l'implémentation dans les classes d'implémentation. Si l'implémentation n'est pas en mesure de fournir une implémentation de toutes les méthodes abstraites, déclarez la classe d'implémentation avec un modificateur abstrait et terminez l'implémentation de la méthode restante dans les classes enfants créées ensuite. Il est possible de déclarer plusieurs classes enfants mais nous avons finalement terminé l'implémentation de toutes les méthodes abstraites.

En général, le processus de développement se déroule étape par étape :

Niveau 1 – interfaces : Il contient les détails du service.
Niveau 2 – classes abstraites : elles contiennent une implémentation partielle.
Niveau 3 – classes d'implémentation : elles contiennent toutes les implémentations.
Niveau 4 – Code final / Méthode principale : Il a accès à toutes les données des interfaces.

Exemple:

// Java Program for // implementation Level wise import java.io.*; import java.lang.*; import java.util.*; // Level 1 interface Bank {  void deposit();  void withdraw();  void loan();  void account(); } // Level 2 abstract class Dev1 implements Bank {  public void deposit()  {  System.out.println('Your deposit Amount :' + 100);  } } abstract class Dev2 extends Dev1 {  public void withdraw()  {  System.out.println('Your withdraw Amount :' + 50);  } } // Level 3 class Dev3 extends Dev2 {  public void loan() {}  public void account() {} } // Level 4 class GFG {  public static void main(String[] args)  {  Dev3 d = new Dev3();  d.account();  d.loan();  d.deposit();  d.withdraw();  } }>

Your deposit Amount :100 Your withdraw Amount :50>

Nouvelles fonctionnalités ajoutées dans les interfaces du JDK 9

À partir de Java 9, les interfaces peuvent également contenir les éléments suivants :

1. Méthodes statiques
2. Méthodes privées
3. Méthodes statiques privées

Points importants dans les interfaces Java

Dans l'article, nous apprenons certains points importants sur les interfaces comme mentionné ci-dessous :

• Nous ne pouvons pas créer une instance (l'interface ne peut pas être instanciée) de l'interface mais nous pouvons en faire la référence qui fait référence à l'objet de sa classe d'implémentation.
• Une classe peut implémenter plusieurs interfaces.
• Une interface peut s'étendre à une autre interface ou interface (plus d'une interface).
• Une classe qui implémente l'interface doit implémenter toutes les méthodes de l'interface.
• Toutes les méthodes sont publiques et abstraites. Et tous les champs sont publics, statiques et finaux.
• Il est utilisé pour réaliser plusieurs héritages.
• Il est utilisé pour obtenir un couplage lâche.
• Dans l'interface, il n'est pas possible de déclarer des variables d'instance car par défaut les variables sont finale statique publique.
• Dans l'interface, les constructeurs ne sont pas autorisés.
• À l’intérieur de l’interface, la méthode principale n’est pas autorisée.
• À l'intérieur de l'interface, la déclaration de méthodes statiques, finales et privées n'est pas possible.

Doit lire

• Spécificateur d'accès aux méthodes dans les interfaces
• Spécificateurs d'accès pour les classes ou les interfaces en Java
• Classes abstraites en Java
• Interface de comparaison en Java
• Méthodes d'interface Java
• Interface imbriquée en Java

Foire aux questions sur les interfaces

1. Qu'est-ce qu'un marqueur ou une interface balisée ?

Les interfaces balisées sont des interfaces sans aucune méthode, elles servent de marqueur sans aucune capacité.

2. Combien de types d’interfaces en Java ?

Les types d'interfaces en Java sont mentionnés ci-dessous :

1. Interface fonctionnelle
2. Interface des marqueurs

3. Pourquoi l'héritage multiple n'est-il pas pris en charge via les classes en Java ?

L'héritage multiple n'est pas pris en charge via les classes en Java afin d'éviter certains défis tels que les problèmes d'ambiguïté et de diamant.