Java >> Tutoriel Java >  >> Java

Interface Java | Définition, Utilisation, Méthodes | Qu'est-ce que ? Comment mettre en œuvre Exemple

Java

Définition de l'interface Java (Qu'est-ce qu'une interface)

Interface Java fournit 100% d'abstraction. L'interface a également des méthodes et des variables identiques à celles d'une classe, mais les méthodes sont par défaut abstraites. Ne répare aucun corps ou phrase dans la méthode la seule déclaration. Et les variables dans l'interface sont constantes, ce qui signifie que les champs sont publics, statiques et finaux par défaut.

L'interface est un ensemble d'instructions ou de plans d'une classe.

Ce didacticiel sur l'interface Java est un aperçu complet et des détails sur tout ce qui concerne l'interface Java. Comme sa définition, son utilisation, ses méthodes par défaut, sa méthode statique, ses variables et comment implémenter l'interface Java.

Remarque : Doit lire les nouvelles fonctionnalités de l'interface Java comme mentionné en bas de ce chapitre.

Utilisation de l'interface en Java

Voici quelques utilisations ou besoins importants d'Interface dans la programmation.

  • La première et principale raison d'utiliser l'interface est d'obtenir une abstraction totale.
  • Java ne prend pas en charge l'héritage multiple par classe, donc avec Interface, l'héritage multiple est possible.
  • Il s'agit de fournir un couplage lâche.

Syntaxe

Voici la syntaxe de l'interface Java, comment déclarer une interface. Pour déclarer une interface, utilisez l'interface mot-clé comme mentionné ci-dessous.

interface <interface_name> {
    // declare constant fields
    // declare abstract methods 
}

Exemple d'interface Java

De la même manière que nous définissons une classe en Java, nous utilisons le "mot-clé de la classe". Ici, vous avez besoin d'un mot-clé "interface" pour créer une interface.

Voici un exemple d'interface Java, comment créer son programme ? Voir ci-dessous le code très facile à faire.

public interface InterfaceExample {
    // Variables
    // methods
}

Un autre exemple avec Quelques méthodes et variables.

public interface MyInterface {

    String hello = "Hello";

    void sayHello();
}

Comment implémenter l'interface Java

Avant d'entrer dans la partie Implémentations, regardons une "Relation entre les classes et les interfaces". Un par un, nous examinerons tous les exemples d'implémentation d'une interface avec classe et interface.

classe - classe :étend

Code : 

class Vehicle {
    void run(){
        System.out.println("Running");
    }
}
 
class TwoWheeler extends Vehicle {
    void wheel(){
        System.out.println("2 Wheeler");
    }
}

classe – interface :implémente

Code : 

public interface MyInterface {

    String hello = "Hello";

    void sayHello();
}

Doit implémenter toutes les méthodes de l'interface.

class MyClass implements MyInterface {
    @Override
    public void sayHello() {

    }
}

interface – interface :étend

Code : 

public interface MyInterface {

    String hello = "Hello";

    void sayHello();
}
public interface OtherInterface extends MyInterface {

}

Les diagrammes supérieurs montrent la relation et les explications, faisons maintenant un exemple pratique "Implémentation d'une interface".

Lorsque la classe doit hériter d'une propriété d'interface, elle doit utiliser le mot-clé implements.

interface Vehicle {

    void maxSpeed();
}

public class Bike implements Vehicle {

    @Override
    public void maxSpeed() {
        System.out.println("120 Km/H");
    }

    public static void main(String arg[]) {
        Bike bike = new Bike();
        bike.maxSpeed();
    }
}

Sortie : 120 km/h

Constructeur d'interface Java

Il n'y a pas de constructeur de l'interface, car comme nous appelons maintenant le besoin d'un constructeur de créer un objet par un nouveau mot-clé. Mais Interface a utilisé par héritage.

Il n'y a donc pas de constructeur jusqu'à présent dans l'interface.

Interface méthodes

Les méthodes par défaut de l'interface Java sont des méthodes abstraites et quelques nouvelles mises à jour depuis Java 8.

Méthode par défaut dans l'interface

Une nouvelle mise à jour de Java 8, la méthode n'est plus seulement une déclaration. Les méthodes de Mena peuvent avoir une copie et des instructions, mais les méthodes doivent être un modificateur d'accès par défaut

Voyons un exemple :

interface NewInterface {

    default void sayHello() {
        System.out.println("default method");
    }
}

class MyClass implements NewInterface {

    public static void main(String args[]) {
        MyClass myClass = new MyClass();
        myClass.sayHello();
    }

    @Override
    public void sayHello() {
        System.out.println("A Interface default method");
    }
}

Sortie : Une méthode par défaut de l'interface

Méthode statique dans l'interface

Identique à Java 8 car il permet désormais d'utiliser des méthodes statiques dans l'interface. Voyons un exemple :

interface NewInterface {

    static void sayHello() {
        System.out.println("The Interface static method");
    }
}

class MyClass implements NewInterface {

    public static void main(String args[]) {
      NewInterface.sayHello();
    }
}

Sortie : La méthode statique Interface

Variables d'interface

Les variables d'interface Java sont une constante avant Java 8, pour l'instant, peuvent contenir à la fois des variables et des constantes. Toutes les variables d'une interface doivent être des modificateurs d'accès public, même si vous lui laissez un mot-clé vide dans la déclaration de la variable.

Fatiguer d'ajouter des variables d'interface en tant que privé ou protégé ou par défaut affichera une erreur - Le modificateur "par défaut ou autre" n'est pas autorisé ici.

héritage d'interface

L'héritage de l'interface Java s'effectue à l'aide du mot clé implements. Il donne également une option en Java pour faire des héritages multiples.

interface Vehicle {

    void maxSpeed();
}

interface Brand{
    void name();
}

public class Bike implements Vehicle,Brand{

    @Override
    public void maxSpeed() {
        System.out.println("120 Km/H");
    }

    @Override
    public void name() {
        System.out.println("Yamaha");
    }

    public static void main(String arg[]) {
        Bike bike = new Bike();
        bike.maxSpeed();
        bike.name();
    }
    
}

Sortie : 120 km/h
Yamaha

Interface imbriquée en Java

Une interface imbriquée est celle qui se trouve à l'intérieur d'une autre interface. Vous trouverez ci-dessous un exemple de code de programmation de Interface imbriquée. Cela revient à définir une classe imbriquée.

public interface MyInterface {

    String hello = "Hello";

    void sayHello();

    interface MessageInterface {
        void msg();
    }
}

Voici les attributs de l'interface Java et quelques règles :

  • Une interface n'a que des méthodes abstraites.
  • La classe peut implémenter n'importe quel nombre d'interfaces.
  • Toutes les méthodes public et les champs sont publics, statiques et finals par défaut. (Modificateurs Java)
  • Une classe doit implémenter toutes les méthodes déclarées d'une interface.

JDK 8 :nouvelles fonctionnalités ajoutées dans les interfaces

Voici les nouvelles fonctionnalités ou modifications de l'interface dans Java 8.

  • Java 8 permet aux interfaces d'avoir des méthodes par défaut et statiques.

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

À partir de Java 9, quelques modifications ont été apportées, les interfaces peuvent contenir les éléments suivants.

  • Méthodes statiques
  • Méthodes privées
  • Méthodes statiques privées

Q :Quels types Java peuvent implémenter des interfaces ?

Réponse : Une interface Java peut être implémentée avec les types suivants dans la liste ci-dessous :

  • Classe Java
  • Classe abstraite
  • Énumération Java
  • Proxy dynamique
  • Classe imbriquée

Faites un commentaire ci-dessous en cas de doute ou de suggestion avec des exemples et des détails.


Balise Java