设计模式心法之接口隔离原则,设计模式心法之

2019-10-06 作者:yzc216.com官网   |   浏览(138)

如需下载源码,请访问

如需下载源码,请访问

文章原创,转载请注明出处:设计模式心法之接口隔离原则

文章原创,转载请注明出处:设计模式心法之依赖倒置原则

——设计模式基本原则之一

依赖倒置原则(Dependence Inversion Principle,DIP)

——设计模式基本原则之一

定义

高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。(High level modules should not depend upon low level modules.Both should depend upon abstractions.Abstractions should not depend upon details.Details should depend upon abstractions.)

高层模块不应该依赖低层模块,即高层模块应该持有抽象类或接口的引用,而不应该持有某一具体实现类的引用。

抽象不应该依赖细节,即接口或抽象类不应该持有某一具体实现类的引用,而应该持有此类所继承抽象类或所实现接口的引用。

细节应该依赖抽象,即实现类也应该持有抽象类或接口的引用,而不应该持有某一具体实现类的引用。

下面我们引用在设计模式心法之单一职责原则中提到过的事例来体验一下依赖倒置原则的优势。

某一产品的生产需要经过原料预处理,原料加工,产品包装,产出成品四个过程,接口如下:

//预处理接口public interface IPreProcess { String preProcess(String material);}

//加工接口public interface IProcess { String process(String material);}

//包装接口public interface IPackaging { String packaging(String semiProduct);}

//产出成品接口public interface IFactory { String process(String product);}

四个接口对应的四个实现类如下:

//原料预处理类public class PreProcess implements IPreProcess{ @Override public String preProcess(String material) { return "*"   material   "——>"; }}

//加工类public class Process implements IProcess { private IPreProcess preProcess; public Process(IPreProcess preProcess) { this.preProcess = preProcess; } @Override public String process(String material) { return this.preProcess.preProcess   "加工——>"; }}

//包装类public class Packaging implements IPackaging { private IProcess process; public Packaging(IProcess process) { this.process = process; } @Override public String packaging(String material) { return this.process.process   "包装——>"; }}

//产出成品类public class FactoryX implements IFactory{ private Packaging packaging; public FactoryX(Packaging packaging) { this.packaging = packaging; } @Override public String process(String material) { return this.packaging.packaging  "产品X"; }}

场景类中调用代码如下:

public class Client { public static void main(String[] args) { produce(new FactoryX(new Packaging(new Process(new PreProcess; } private static void produce(IFactory factory){ System.out.println(factory.process; }}

运行后,结果如下:

*原料——>加工——>包装——>产品X

从示例中我们发现,后三个过程的实现类,均持有上一个过程接口的引用,而不是某一具体实现类的引用。这样做的好处是一旦某一过程需要变更,只需要变更这一过程所对应接口的具体实现类即可,其他过程可以不用作出更改。例如,现在优化产品X的加工过程,采用升级后的加工方案2Process2进行加工,代码如下:

public class Process2 implements IProcess{ private IPreProcess preProcess; public Process2(IPreProcess preProcess) { this.preProcess = preProcess; } @Override public String process(String material) { return this.preProcess.preProcess   "优化加工——>"; }}

在场景类中只需要做微小的修改即可(不仔细看可能找不到改的哪):

public class Client { public static void main(String[] args) { produce(new FactoryX(new Packaging(new Process2(new PreProcess; } private static void produce(IFactory factory){ System.out.println(factory.process; }}

运行后发现产品X的生产过程已经采用优化后的加工方案了

*原料——>优化加工——>包装——>产品X

通过上述更改我们发现,在优化产品X的加工方案的过程中,只添加了一个加工接口的实现类Process2,其后续过程并没有发生改变,原因是后续包装过程Packaging持有的是加工过程的接口IProcess,而不是具体的某一实现类,如果将接口IProcess改为某一具体的实现类,再作出上述更改,恐怕连编译也通过不了。

如果场景类中,想调用产品Y的生产,只需要给生产方法produce(IFactory factory)传入产品Y 的实现类即可,代码如下:

public class Client { public static void main(String[] args) { produce(new FactoryX(new Packaging(new Process2(new PreProcess; produce(new FactoryY(new Packaging(new Process(new PreProcess; } private static void produce(IFactory factory){ System.out.println(factory.process; }}

运行结果如下:

*原料——>优化加工——>包装——>产品X*原料——>加工——>包装——>产品Y

方法produce(IFactory factory)依然不需要变化,便可输出想要的结果,原因是方法produce(IFactory factory)的形参接收的是接口类型,而不是具体的某一实现类的类型。

定义:

客户端不应该依赖它不需要的接口(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; String product = factory.processA2; System.out.println(factory.packaging; }}

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; String product = factory.processB2; System.out.println(factory.packaging; }}

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; String product = factory.processA2; System.out.println(subFactory.packaging; }}

运行结果如下:

原料-->预处理-->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; String product = factory.processB2; System.out.println(subFactory.packaging; }}

运行结果如下:

原料-->预处理-->b1工序半成品加工-->b2工序半成品加工-->包装成品

相同的运行结果下,实现类FactoryA和FactoryB中均不存在其场景类中使用不到的方法,如果以后因需求变化过大,更改接口IFactoryA,也不会对实现类FactoryB造成任何影响。这样设计的接口在应对未来变更时,会更具有灵活性和可拓展性。

本文由yzc216亚洲城发布于yzc216.com官网,转载请注明出处:设计模式心法之接口隔离原则,设计模式心法之

关键词: yzc216亚洲城 yzc216.com官网