04-接口隔离原则(ISP)

1. 背景

类A通过接口I依赖类B，类C通过接口I依赖类D，如果接口I对于类B和类D来说不是最小接口,则类B和类D不得不去实现它们不需要的方法。

2. 定义

一个类对另一个类的依赖应该建立在最小的接口上，不应该依赖他不需要的接口。

3. 解决方案

将臃肿的接口I拆分为独立的几个接口，类A和类C分别于它们需要的接口建立依赖关系，即接口隔离原则。

4. 模拟场景

接口I中有5个方法, 类A通过接口I依赖于类B,但类A只需要方法1、方法2、方法3；类C通过接口I依赖于类D，但类C只需要方法1、方法4、方法5。

以上这种业务场景：我们发现，对类B来说，方法4和方法5不是必须的，但不得不实现；对于类D来说，方法2和方法3不是必须的，但不得不实现,显然不满足接口隔离原则。

解决方案：将接口I拆分成三个接口 I1、I2、I3；I1中有方法1；I2中有方法2、方法3；I3中有方法4、方法5。B实现接口I1和I2，D实现接口I1和I3；这样就满足最小接口依赖了，即满足接口隔离原则了

注意：为了和上面的代码区分：A用AA表示，B用BB表示，一次类推

1  public interface I1
2     {
3          void methord1();
4     }

1  public interface I2
2     {
3         void methord2();
4         void methord3();
5     }

1   public interface I3
2     {
3         void methord4();
4         void methord5();
5     }

 1  public class BB : I1, I2
 2     {
 3         public void methord1()
 4         {
 5             Console.WriteLine("类BB实现接口I1的方法1");
 6         }
 7 
 8         public void methord2()
 9         {
10             Console.WriteLine("类BB实现接口I2的方法2");
11         }
12 
13         public void methord3()
14         {
15             Console.WriteLine("类BB实现接口I2的方法3");
16         }
17     }

 1  public class DD:I1,I3
 2     {
 3         public void methord1()
 4         {
 5             Console.WriteLine("类DD实现接口I1的方法1");
 6         }
 7 
 8         public void methord4()
 9         {
10             Console.WriteLine("类DD实现接口I3的方法4");
11         }
12 
13         public void methord5()
14         {
15             Console.WriteLine("类DD实现接口I3的方法5");
16         }
17     }

 1  public class AA
 2     {
 3        public void Depend1(I1 i)
 4        {
 5            i.methord1();
 6        }
 7        public void Depend2(I2 i)
 8        {
 9            i.methord2();
10        }
11        public void Depend3(I2 i)
12        {
13            i.methord3();
14        }
15     }

 1  public  class CC
 2     {
 3         public void Depend1(I1 i)
 4         {
 5             i.methord1();
 6         }
 7         public void Depend4(I3 i)
 8         {
 9             i.methord4();
10         }
11         public void Depend5(I3 i)
12         {
13             i.methord5();
14         }
15     }

 1  public static void show2()
 2         {
 3            
 4             //解决上述业务场景，使其满足接口隔离原则
 5             //解决方案：将接口I拆分成三个接口 I1、I2、I3；I1中有方法1；I2中有方法2、方法3；I3中有方法4、方法5。B实现接口I1和I2，D实现接口I1和I3；这样就满足最小接口依赖了，
 6             //即满足接口隔离原则了
 7             //注意：为了和上面的代码区分：A用AA表示，B用BB表示，一次类推
 8             AA aa = new AA();
 9             aa.Depend1(new BB());
10             aa.Depend2(new BB());
11             aa.Depend3(new BB());
12             CC cc = new CC();
13             cc.Depend1(new DD());
14             cc.Depend4(new DD());
15             cc.Depend5(new DD());
16 
17         }