[JAVA] Avantages de l'interface

introduction

L'interface a l'avantage d'aider à la conception de la classe, comme la définition d'opérations communes entre les classes en tant que groupe, ou la définition d'une interface vide pour donner à la classe d'implémentation certaines caractéristiques et clarifier l'intention de traitement. Il y a plusieurs.

Parmi eux, de nombreuses personnes peuvent penser que les points suivants sont les plus grands avantages de l'interface.

Cependant, je ne pouvais pas trier ces significations, alors j'ai décidé de les trier dans mes propres mots [^ moi].

Si vous n'utilisez pas l'interface ...

Par exemple, supposons que vous définissiez trois méthodes de la classe A comme suit:

python


class A {
    //Méthode pour appeler
    void call() {
        System.out.println("Frapper / Porter / Jankenpon");
    }
    //Méthode Jacques
    void jakajaka() {
        System.out.println(
            "Jakajakajan, Jakajakajan, Jakajakajakajaka, Jankenpawn!"
        );
    }
    //Méthode de danse
    void odoru() {
        System.out.println("L'incident se produit dans la salle de conférence.");
        System.out.println("Non, c'est le site.");
        System.out.println("C'est une salle de réunion.");
        System.out.println("Site, site.");
        System.out.println("Salle de réunion, salle de réunion, salle de réunion.");
        System.out.println("Site, site, site, site,...Salle sur le terrain! !! !!");
    }
}

Et supposons que vous ayez défini le code suivant pour utiliser cette classe:

python


A a = new A();
a.call();
a.jakajaka();
a.odoru();

Faire cela, bien sûr, imprimera le message défini par chaque méthode.

Ici, on suppose qu'une nouvelle classe B avec une implémentation modifiée de la classe A est nouvellement établie comme suit, et l'utilisateur est ** appelé à utiliser la classe B au lieu de la classe A à l'avenir **.

Modifications de la mise en œuvre


class B {
    //Supprimer la méthode d'appel
    //Changement du nom de la méthode de jakajaka pour chanter
    void sing() {
        ... //Comme ci-dessus
    }
    //Changement du nom de la méthode de odoru en genbashitsu
    void genbashitsu() {
        ... //Comme ci-dessus
    }
}

Puisque l'utilisateur doit arrêter d'utiliser la classe A et utiliser la classe B, il est nécessaire de comprendre l'implémentation de la classe B et de modifier le code jusqu'à présent comme suit.

python


B b = new B();
b.sing();
b.genbashitsu();

Bien que le même message que précédemment soit émis par la méthode sing et la méthode genbashitsu, l'utilisateur qui était en difficulté parce que la méthode d'appel ne pouvait pas être utilisée ** a utilisé certaines fonctions de classe A contrairement à l'appel **. Je vais.

Exemple de violation


A a = new A(); //Violation de l'appel
a.call();      //Violation de l'appel
B b = new B();
b.sing();
b.genbashitsu();

Cela peut être un bon ad hoc, mais si la classe A était obsolète, toute partie de celle-ci accédant à la classe A pourrait entraîner une erreur de compilation. Dans ce cas, vous devrez réparer cette pièce à l'avenir.

Sans l'interface de cette manière, lorsque des modifications d'implémentation se produisent, l'utilisateur doit être conscient des modifications de la nouvelle implémentation et modifier le code pour conserver la même implémentation qu'auparavant. Vous devrez réfléchir à ce que vous avez à faire. De plus, si vous utilisez une ancienne fonctionnalité que vous ne devriez pas utiliser, vous devrez passer du temps à la réparer lorsque cette fonctionnalité sera interrompue à l'avenir.

Avec l'interface ...

Vous pouvez utiliser l'interface pour informer l'utilisateur des méthodes disponibles. Tant que l'utilisateur connaît les fonctions définies dans l'interface et les fonctions de la classe d'implémentation à utiliser, même si l'implémentation est modifiée, il n'est pas nécessaire de vérifier les méthodes disponibles et les méthodes indisponibles.

python


interface Contract {
  void call();
  void sing();
  void genbashitsu();
}

python


class B implements Contract {
    //Méthode pour appeler
    @Override public void call() {}; //Mise en œuvre vide
    //Méthode Jacques
    @Override public void sing() {
        ... //Comme ci-dessus
    }
    //Méthode de danse
    @Override public void genbashitsu() {
        ... //Comme ci-dessus
    }
}

De plus, si la classe qui implémente l'interface a une méthode d'implémentation vide, l'utilisateur pourra implémenter cette méthode en utilisant une classe anonyme si nécessaire [^ Implémentation vide] ].

Exemple d'utilisation de l'interface


Contract c = new B() {
    @Override public void call() {
        System.out.println("Frapper / Porter / Jankenpon");
    }
};
c.call();        //Frapper / Porter / Jankenpon
c.sing();        //Jakajakajan, Jakajakajan, Jakajakajakajaka, Jankenpawn!
c.genbashitsu(); //L'incident est ... la salle du site! !! !!

Résumé

L'interface permet aux utilisateurs de créer des programmes flexibles sans être effrayés par le besoin de modifications dues aux changements d'implémentation. Si une nouvelle classe d'implémentation apparaît comme le code suivant et que vous souhaitez utiliser cette classe, vous pouvez utiliser cette implémentation simplement en modifiant l'instance générée.

Nouvelle classe d'implémentation


class NewB implements Contract {
  //Méthode pour appeler
  @Override public void call() {}; //Mise en œuvre vide
  //Méthode Jacques
  @Override public void sing() {
    System.out.println("Oui Air");
  }
  //Méthode de danse
  @Override public void genbashitsu() {
    System.out.println("Lalala Love Sun Buddy Tonight Sticky Spring Printemps Printemps Printemps Valeza Love Go");
  }
}

Changer de classe à utiliser


Contract c = new NewB() {
    @Override public void call() {
        System.out.println("Frapper / Porter / Jankenpon");
    }
};
c.call();        //Frapper / Porter / Jankenpon
c.sing();        //Oui Air
c.genbashitsu(); //Lalala Love Sun Buddy Tonight Sticky Spring Printemps Printemps Printemps Valeza Love Go

[^ User]: la personne qui utilise la classe définie. même que ci-dessous.

[^ Contrat]: les exigences et les spécifications que le programme doit respecter.

[^ moi]: Honnêtement, je ne suis pas confiant car je ne suis qu'un amateur sans expérience pratique. Si vous trouvez des erreurs d'interprétation, nous vous serions reconnaissants de bien vouloir les signaler ou de faire des suggestions.

[^ Implémentation vide]: Si vous utilisez une classe anonyme, vous pouvez remplacer toute méthode accessible même si ce n'est pas une implémentation vide.

Recommended Posts

Avantages de l'interface
interface
java (interface)
nouvelle interface
interface [java]
À propos de l'interface Java
[Android] exemple d'interface
Introduction de l'interface fonctionnelle
Exemple d'utilisation de l'interface
interface et résumé
Interface [Java]
[Java] Interface fonctionnelle
À propos de l'interface, interface java
Héritage et interface.