如需下载源码，请访问
https://github.com/fengchuanfang/Interface_Segregation_Principle
文章原创，转载请注明出处：
设计模式心法之接口隔离原则
接口隔离原则（ISP，Interface Segregation Principle）
——设计模式基本原则之一
定义：
客户端不应该依赖它不需要的接口（Clients should not be forced to depend upon interfaces that they don't use）
类间的依赖关系应该建立在最小的接口上（The dependency of one class to another one should depend on the smallest possible interface）
接口是静态常量和抽象方法的集合，既是其引用持有类依赖关系的协议，也是其实现类的规范。接口的设计在一个项目的开发中起到举足轻重的作用，是使项目保持良好拓展性的关键。
接口隔离原则要求我们在设计接口时，要使用多个专门的接口不要使用单一的庞大臃肿的总接口，一个类对另一个类的依赖性应该建立在最小的接口上。要做到接口与角色一一对应，不应该让一个接口承担多个角色，也不应该让一个角色由多个接口承担。这样设计的接口在应对未来变更时，会更具有灵活性和可拓展性。
有一工厂接口对外提供原料预处理（preProcess），半成品加工（processA1，processA2，processB1，processB2），产品包装（packaging）等方法，如下：
public interface IFactory {
String preProcess(String material);
String processA1(String semis);
String processA2(String semis);
String processB1(String semis);
String processB2(String semis);
String packaging(String product);
}
场景类ClientA通过接口IFactory依赖类FactoryA中的preProcess，processA1，processA2，packaging方法，代码如下：
public class ClientA {
public static void main(String args[]) {
IFactory factory = new FactoryA();
String semis1 = factory.preProcess("原料");
String semis2 = factory.processA1(semis1);
String product = factory.processA2(semis2);
System.out.println(factory.packaging(product));
}
}
public class FactoryA implements IFactory {
@Override
public String preProcess(String material) {
return material + "-->预处理";
}
@Override
public String processA1(String semis) {
return semis + "-->a1工序半成品加工";
}
@Override
public String processA2(String semis) {
return semis + "-->a2工序半成品加工";
}
@Override
public String processB1(String semis) {
return null;
}
@Override
public String processB2(String semis) {
return null;
}
@Override
public String packaging(String product) {
return product + "-->包装成品";
}
}
运行结果如下：
原料-->预处理-->a1工序半成品加工-->a2工序半成品加工-->包装成品
场景类ClientB通过接口IFactory依赖类FactoryB中的preProcess，processB1，processB2，packaging方法，代码如下：
public class ClientB {
public static void main(String[] args) {
IFactory factory = new FactoryB();
String semis1 = factory.preProcess("原料");
String semis2 = factory.processB1(semis1);
String product = factory.processB2(semis2);
System.out.println(factory.packaging(product));
}
}
public class FactoryB implements IFactory {
@Override
public String preProcess(String material) {
return material + "-->预处理";
}
@Override
public String processA1(String semis) {
return null;
}
@Override
public String processA2(String semis) {
return null;
}
@Override
public String processB1(String semis) {
return semis + "-->b1工序半成品加工";
}
@Override
public String processB2(String semis) {
return semis + "-->b2工序半成品加工";
}
@Override
public String packaging(String product) {
return product + "-->包装成品";
}
}
运行结果如下：
原料-->预处理-->b1工序半成品加工-->b2工序半成品加工-->包装成品
在上述示例中，接口IFactory对于类ClientA和ClientB来说，均不是最小接口，IFactory中存在着类ClientA和ClientB使用不到的方法。但是作为IFactory的实现类FactoryA和FactoryB不得不去实现场景类中使用不到的方法。
IFactory作为场景类ClientA，ClientB依赖对应工厂类FactoryA,FactoryB之间的协议过于繁琐，作为其子类FactoryA,FactoryB的规范过于臃肿，这种设计显然太过于死板而不够灵活。如果以后因需求变更过大，无论场景类ClientA还是ClientB所依赖的接口需要更改，都会导致另一个场景类所依赖的接口实现类去实现场景类中使用不到的方法来适应这种变更，
我们可以按照接口隔离原则将IFactory拆分成以下三个接口，
public interface ISubFactory {
String preProcess(String material);
String packaging(String product);
}
public interface IFactoryA {
String processA1(String semis);
String processA2(String semis);
}
public interface IFactoryB {
String processB1(String semis);
String processB2(String semis);
}
然后由类FactoryA实现接口ISubFactory和IFactoryA，代码如下：
public class FactoryA implements ISubFactory,IFactoryA{
@Override
public String preProcess(String material) {
return material + "-->预处理";
}
@Override
public String processA1(String semis) {
return semis + "-->a1工序半成品加工";
}
@Override
public String processA2(String semis) {
return semis + "-->a2工序半成品加工";
}
@Override
public String packaging(String product) {
return product + "-->包装成品";
}
}
场景类中代码如下：
public class ClientA {
public static void main(String[] args) {
ISubFactory subFactory = new FactoryA();
IFactoryA factory = new FactoryA();
String semis1 = subFactory.preProcess("原料");
String semis2 = factory.processA1(semis1);
String product = factory.processA2(semis2);
System.out.println(subFactory.packaging(product));
}
}
运行结果如下:
原料-->预处理-->a1工序半成品加工-->a2工序半成品加工-->包装成品
由类FactoryB实现接口ISubFactory和IFactoryB，代码如下：
public class FactoryB implements ISubFactory, IFactoryB {
@Override
public String preProcess(String material) {
return material + "-->预处理";
}
@Override
public String processB1(String semis) {
return semis + "-->b1工序半成品加工";
}
@Override
public String processB2(String semis) {
return semis + "-->b2工序半成品加工";
}
@Override
public String packaging(String product) {
return product + "-->包装成品";
}
}
场景类中代码如下：
public class ClientB {
public static void main(String[] args) {
ISubFactory subFactory = new FactoryB();
IFactoryB factory = new FactoryB();
String semis1 = subFactory.preProcess("原料");
String semis2 = factory.processB1(semis1);
String product = factory.processB2(semis2);
System.out.println(subFactory.packaging(product));
}
}
运行结果如下：
原料-->预处理-->b1工序半成品加工-->b2工序半成品加工-->包装成品
相同的运行结果下，实现类FactoryA和FactoryB中均不存在其场景类中使用不到的方法，如果以后因需求变化过大，更改接口IFactoryA,也不会对实现类FactoryB造成任何影响。这样设计的接口在应对未来变更时，会更具有灵活性和可拓展性。
网友评论