设计模式的六大原则实例优质文档.docx

设计模式的六大原则实例优质文档.docx

《设计模式的六大原则实例优质文档.docx》由会员分享，可在线阅读，更多相关《设计模式的六大原则实例优质文档.docx（18页珍藏版）》请在冰豆网上搜索。

设计模式的六大原则实例优质文档

一、设计模式的六大原则

1、开闭原则（OpenClosePrinciple）

开闭原则就是说对扩展开放，对修改关闭。

在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。

所以一句话概括就是：

为了使程序的扩展性好，易于维护和升级。

想要达到这样的效果，我们需要使用接口和抽象类。

开闭原则是面向对象的可复用设计的第一块基石。

开闭原则的关键是抽象化。

2、里氏代换原则（LiskovSubstitutionPrinciple）

里氏代换原则（LiskovSubstitutionPrincipleLSP）面向对象设计的基本原则之一。

里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。

LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。

里氏代换原则是对“开-闭”原则的补充。

实现“开-闭”原则的关键步骤就是抽象化。

而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。

面向对象的设计关注的是对象的行为，它是使用“行为”来对对象进行分类的，只有行为一致的对象才能抽象出一个类来。

我经常说类的继承关系就是一种“Is-A”关系，实际上指的是行为上的“Is-A”关系，可以把它描述为“Act-As”。

3、依赖倒转原则（DependenceInversionPrinciple）

这个是开闭原则的基础，具体内容：

真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（InterfaceSegregationPrinciple）

这个原则的意思是：

使用多个隔离的接口，比使用单个接口要好。

还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。

所以上文中多次出现：

降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（DemeterPrinciple）

最少知道原则，就是说：

一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（CompositeReusePrinciple）

合成/聚合复用原则是在一个新的对象里面使用一些已有的对象，使之成为新对象的一部分；新的对象通过向这些对象的委派达到复用已有功能的目的。

合成（Composition）和聚合（Aggregation）都是关联（Association）的特殊种类。

原则是尽量使用合成/聚合的方式，而不是使用继承。

11.开闭原则实例

Fruit接口：

抽象产品

Orange类：

实现fruit接口，具体产品

Apple类：

实现Fruit接口，具体产品

Gardener接口：

抽象工厂

AppleGardener类：

实现Gardener接口，具体工厂，分管apple生产

OrangeGardener类：

实现Gardener接口，具体工厂，分管orange生产

packagecom.zky.www.factory;

publicinterfaceFruit{//水果接口

publicvoidplant（）;

publicvoidgrow（）;

publicvoidharvest（）;

}

publicclassAppleimplementsFruit{//苹果实现水果接口

publicvoidgrow（）{

System.out.println（"appleisgrowing!

"）;

}

publicvoidharvest（）{

System.out.println（"appleisharvesting!

"）;

}

publicvoidplant（）{

System.out.println（"appleisplanting!

"）;

}

}

publicclassOrangeimplementsFruit{

//桔子实现水果接口

publicvoidgrow（）{

System.out.println（"orangeisgrowing!

"）;

}

publicvoidharvest（）{

System.out.println（"orangeisharvesting!

"）;

}

publicvoidplant（）{

System.out.println（"orangeisplanting!

"）;

}

}

publicinterfaceGardener{//园丁接口

publicFruitgetFruit（）;

}

publicclassAppleGardenerimplementsGardener{

@Override

publicFruitgetFruit（）{

returnnewApple（）;

}

}

publicclassOrangeGradenerimplementsGardener{

@Override

publicFruitgetFruit（）{

returnnewOrange（）;

}

}

publicclassClient{

publicstaticvoidmain（String[]args）{

Gardenerg1=newAppleGardener（）;

Appleapple=（Apple）g1.getFruit（）;

apple.harvest（）;

}

}

22、里氏代换原则实例

正方形不是长方形

packagecom.zky.www.liskov;

publicclassRectangle{

privatedoublewidth;

privatedoubleheight;

publicRectangle（）{}

publicRectangle（doublewidth,doubleheight）{

super（）;

this.width=width;

this.height=height;

}

publicdoublegetWidth（）{

returnwidth;

}

publicvoidsetWidth（doublewidth）{

this.width=width;

}

publicdoublegetHeight（）{

returnheight;

}

publicvoidsetHeight（doubleheight）{

this.height=height;

}

}

packagecom.zky.www.liskov;

publicclassSquareextendsRectangle{

privatedoubleside;

publicSquare（doubleside）{

super（）;

this.side=side;

}

publicdoublegetSide（）{

returnside;

}

publicvoidsetSide（doubleside）{

this.side=side;

}

}

packagecom.zky.www.liskov;

publicclassSmartTest{

publicvoidresize（Rectangler）

{

while（r.getHeight（）<=r.getWidth（））

{

r.setWidth（r.getWidth（）+1）;

}

}

}

33、依赖倒转原则实例

public class Benz{

 //汽车肯定会跑

  public void run（）{

  System.out.println（"奔驰汽车开始运行..."）;

}

}

public class Driver{

//司机的主要职责就是驾驶汽车

public void drive（Benzbenz）{

benz.run（）;

}

}

public class Client{

public static void main（String[]args）{

DriverzhangSan=new Driver（）;

Benzbenz=new Benz（）;

//张三开奔驰车

zhangSan.drive（benz）;

}

}

上面实例，司机张三只能开奔驰车，不能开其他车，因此设计出了问题，改正如下。

public interface IDriver{

//是司机就应该会驾驶汽车

public void drive（ICarcar）;

}

public class Driverimplements IDriver{

  //司机的主要职责就是驾驶汽车

  public void drive（ICarcar）{

 car.run（）;

}

}

public interface ICar{

//是汽车就应该能跑

public void run（）;

}

public class Benzimplements ICar{

//汽车肯定会跑

public void run（）{

System.out.println（"奔驰汽车开始运行..."）;

}

}

public class BMWimplements ICar{

//宝马车当然也可以开动了

public void run（）{

System.out.println（"宝马汽车开始运行..."）;

}

}

 在业务场景中，我们贯彻“抽象不应该依赖细节”，也就是我们认为抽象（ICar接口）不依赖BMW和Benz两个实现类（细节），因此我们在高层次的模块中应用都是抽象，Client的实现过程如下：

publicclassClient{

publicstaticvoidmain（String[]args）{

IDriverzhangSan=newDriver（）;

ICarbenz=newBenz（）;

//张三开奔驰车

zhangSan.drive（benz）;

}

}

  Client属于高层业务逻辑，它对低层模块的依赖都建立在抽象上，zhangSan的显示类型是IDriver，benz的显示类型是ICar，也许你要问，在这个高层模块中也调用到了低层模块，比如newDriver（）和newBenz（）等，如何解释？

确实如此，zhangSan的显示类型是IDriver，是一个接口，是抽象的，非实体化的，在其后的所有操作中，zhangSan都是以IDriver类型进行操作，屏蔽了细节对抽象的影响。

当然，张三如果要开宝马车，也很容易，我们只要修改业务场景类就可以。

注意在Java中，只要定义变量就必然要有类型，一个变量可以有两