Exemple d'explication du principe d'isolation d'interface en Java

Cet article présente principalement le principe d'isolation de l'interface. L'éditeur pense que c'est plutôt bien, je vais le partager avec vous maintenant et le donner comme référence. Suivons l'éditeur et jetons un coup d'œil.

Définition : Le client ne doit pas s'appuyer sur des interfaces dont il n'a pas besoin ; la dépendance d'une classe à l'égard d'une autre classe doit être basée sur la plus petite interface ; .

Origine du problème : La classe A dépend de la classe B via l'interface I, la classe C dépend de la classe D via l'interface I, si l'interface I n'est pas l'interface minimale pour la classe A et class B , alors la classe B et la classe D doivent implémenter les méthodes dont elles n'ont pas besoin.

Solution : Divisez l'interface gonflée I en plusieurs interfaces indépendantes, et la classe A et la classe C établissent des dépendances avec les interfaces dont elles ont respectivement besoin. C'est-à-dire que le principe d'isolation des interfaces est adopté.
Un exemple pour illustrer le principe d'isolation de l'interface :

(Figure 1 Conception qui ne suit pas le principe d'isolation de l'interface)

Quoi cette image signifie : La classe A dépend de la méthode 1, de la méthode 2 et de la méthode 3 dans l'interface I. La classe B est l'implémentation de la dépendance de la classe A. La classe C dépend de la méthode 1, de la méthode 4 et de la méthode 5 dans l'interface I, et la classe D est l'implémentation de la dépendance à la classe C. Pour les classes B et D, bien qu'elles aient toutes deux des méthodes inutilisées (c'est-à-dire les méthodes marquées en rouge sur la figure), puisque l'interface I est implémentée, ces méthodes inutilisées doivent également être implémentées. Ceux qui ne sont pas familiers avec les diagrammes de classes peuvent se référer au code du programme pour le comprendre. Le code est le suivant :

interface I {
  public void method1();
  public void method2();
  public void method3();
  public void method4();
  public void method5();
}

class A{
  public void depend1(I i){
    i.method1();
  }
  public void depend2(I i){
    i.method2();
  }
  public void depend3(I i){
    i.method3();
  }
}

class B implements I{
  public void method1() {
    System.out.println("类B实现接口I的方法1");
  }
  public void method2() {
    System.out.println("类B实现接口I的方法2");
  }
  public void method3() {
    System.out.println("类B实现接口I的方法3");
  }
  //对于类B来说，method4和method5不是必需的，但是由于接口A中有这两个方法，
  //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
  public void method4() {}
  public void method5() {}
}

class C{
  public void depend1(I i){
    i.method1();
  }
  public void depend2(I i){
    i.method4();
  }
  public void depend3(I i){
    i.method5();
  }
}

class D implements I{
  public void method1() {
    System.out.println("类D实现接口I的方法1");
  }
  //对于类D来说，method2和method3不是必需的，但是由于接口A中有这两个方法，
  //所以在实现过程中即使这两个方法的方法体为空，也要将这两个没有作用的方法进行实现。
  public void method2() {}
  public void method3() {}

  public void method4() {
    System.out.println("类D实现接口I的方法4");
  }
  public void method5() {
    System.out.println("类D实现接口I的方法5");
  }
}

public class Client{
  public static void main(String[] args){
    A a = new A();
    a.depend1(new B());
    a.depend2(new B());
    a.depend3(new B());

    C c = new C();
    c.depend1(new D());
    c.depend2(new D());
    c.depend3(new D());
  }
}

Comme vous pouvez le voir, si l'interface est trop volumineuse, tant qu'elle apparaît dans l'interface, les méthodes, qu'elles soient utiles ou non aux classes qui en dépendent, doivent être implémentées dans la classe d'implémentation. Ce n'est évidemment pas une bonne conception. Si cette conception est modifiée pour se conformer au principe d'isolation de l'interface, l'interface I doit être divisée. Ici, nous divisons l'interface originale I en trois interfaces. La conception divisée est illustrée dans la figure 2 :

(la figure 2 suit le principe d'isolation de l'interface)

Publiez le code du programme comme d'habitude pour la référence des amis qui ne sont pas familiers avec les diagrammes de classes :

interface I1 {
  public void method1();
}

interface I2 {
  public void method2();
  public void method3();
}

interface I3 {
  public void method4();
  public void method5();
}

class A{
  public void depend1(I1 i){
    i.method1();
  }
  public void depend2(I2 i){
    i.method2();
  }
  public void depend3(I2 i){
    i.method3();
  }
}

class B implements I1, I2{
  public void method1() {
    System.out.println("类B实现接口I1的方法1");
  }
  public void method2() {
    System.out.println("类B实现接口I2的方法2");
  }
  public void method3() {
    System.out.println("类B实现接口I2的方法3");
  }
}

class C{
  public void depend1(I1 i){
    i.method1();
  }
  public void depend2(I3 i){
    i.method4();
  }
  public void depend3(I3 i){
    i.method5();
  }
}

class D implements I1, I3{
  public void method1() {
    System.out.println("类D实现接口I1的方法1");
  }
  public void method4() {
    System.out.println("类D实现接口I3的方法4");
  }
  public void method5() {
    System.out.println("类D实现接口I3的方法5");
  }
}

Isolement de l'interface La signification Le principe est le suivant : construire une seule interface, ne pas construire une interface énorme et volumineuse, essayer d'affiner l'interface autant que possible et avoir le moins de méthodes possible dans l'interface. En d’autres termes, nous devons établir des interfaces dédiées pour chaque classe, plutôt que d’essayer de créer une énorme interface pour toutes les classes qui en dépendent pour appeler. Dans l'exemple de cet article, le principe d'isolation d'interface est utilisé pour transformer une énorme interface en trois interfaces dédiées. En programmation, il est plus flexible de s’appuyer sur plusieurs interfaces dédiées que de s’appuyer sur une seule interface complète. Les interfaces sont des « contrats » définis en externe lors de la conception. En définissant de manière décentralisée plusieurs interfaces, nous pouvons empêcher la propagation de modifications externes et améliorer la flexibilité et la maintenabilité du système.

En parlant de cela, beaucoup de gens penseront que le principe d'isolation de l'interface est très similaire au précédent principe de responsabilité unique, mais ce n'est pas le cas. Premièrement, le principe de responsabilité unique se concentrait à l’origine sur les responsabilités, tandis que le principe d’isolement des interfaces se concentrait sur l’isolement des dépendances des interfaces. Deuxièmement, le principe de responsabilité unique contraint principalement les classes, suivis des interfaces et des méthodes, et cible la mise en œuvre et les détails du programme tandis que le principe d'isolation des interfaces contraint principalement les interfaces, principalement pour l'abstraction, et pour la construction du cadre global du programme ; programme.

Lorsque vous utilisez le principe d'isolation d'interface pour contraindre les interfaces, faites attention aux points suivants :

• L'interface doit être aussi petite que possible, mais dans certaines limites. C'est un fait qu'affiner l'interface peut améliorer la flexibilité de la programmation, mais si elle est trop petite, cela entraînera trop d'interfaces et compliquera la conception. Il faut donc le faire avec modération.

• Personnalisez les services pour les classes qui s'appuient sur des interfaces, en exposant uniquement les méthodes dont elles ont besoin à la classe appelante, tout en masquant les méthodes dont elles n'ont pas besoin. Ce n'est qu'en se concentrant sur la fourniture de services personnalisés pour un module que des dépendances minimales peuvent être établies.

• Améliorer la cohésion et réduire les interactions extérieures. Faites en sorte que l'interface utilise le moins de méthodes pour accomplir le plus de choses.

Utilisez le principe d'isolation de l'interface et il doit être modéré. Il n'est pas bon de concevoir l'interface trop grande ou trop petite. Lors de la conception d'une interface, ce n'est qu'en passant plus de temps à réfléchir et à planifier que vous pourrez mettre en œuvre ce principe avec précision

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!