2016-05-14 20:45:38
设计模式到底是五大、六大还是七大，一直傻傻分不清楚，网上总是有说那些原则可以归为一个，我纠结了半天，突然发现自己是舍本逐末了，只要清楚这些原则的设计思想，其他的理解自然是水到渠成。
1、开放-封闭原则
2、单一职责原则
3、里氏代换原则
4、依赖倒转原则
5、迪米特法则
6、接口隔离原则
7、合成/聚合复用原则
一、开放封闭原则（open-closed principle）
一个软件实体应当对外拓展开放，对修改关闭。
在设计一个模块时，应当使得这个模块可以在不被修改的前提下被扩展。也就是说，应当可以在不必修改源代码的情况下修改这个模块的行为。
设计的目的便在于面对需求的改变而保持系统的相对稳定，从而使得系统可以很容易的从一个版本升级到另一个版本。
例子：银行业务员
先前的模式：
每个银行业务员都要负责储户的付款、取款、转账等业务，当业务变更时，所有银行业务员的职责都要发生变化，业务少了自然能够轻松，业务多了所有人都要培训，拓展性不好，而通常来说，储户的需求是不断增加的。
/*
* 银行业务员
*/
public class BankWorker {
//负责存款业务
public void saving() {
System.out.println("进行存款操作");
} //负责取款业务
public void drawing() {
System.out.println("进行取款操作");
} //负责转账业务
public void zhuanzhang() {
System.out.println("进行转账操作");
} //负责基金的申购
public void jijin() {
System.out.println("进行基金申购操作");
}
}
public class MainClass {
public static void main(String[] args) {
BankWorker bankWorker = new BankWorker();
//存款
bankWorker.saving();
//取款
bankWorker.drawing();
//转账
bankWorker.zhuanzhang();
//基金
bankWorker.jijin();
}
}
修改后的模式:
一个银行业务员专门负责一个业务，非常方便业务的增加，只要继续安排对应的银行业务员即可。
/*
* 银行业务员接口，是所有银行业务员的抽象父类。
*/
public interface BankWorker {
public void operation();
}
/*
* 负责取款业务的业务员
*/
public class DrawingBankWorker implements BankWorker{
public void operation() {
System.out.println("进行取款操作");
}
}
/*
* 负责存款业务的业务员
*/
public class SavingBankWorker implements BankWorker {
public void operation() {
System.out.println("进行存款操作");
}
}
/*
* 负责转账业务的业务员
*/
public class ZhuanZhangBankWorker implements BankWorker {
public void operation() {
System.out.println("进行转账操作");
}
}
/*
* 负责基金业务的业务员
*/
public class JiJinBankWorker implements BankWorker {
public void operation() {
System.out.println("进行基金申购操作");
}
}
public class MainClass {
public static void main(String[] args) {
BankWorker bankWorker = new SavingBankWorker();
bankWorker.operation();
BankWorker bankWorker2 = new DrawingBankWorker();
bankWorker2.operation();
BankWorker bankWorker3 = new ZhuanZhangBankWorker();
bankWorker3.operation();
BankWorker bankWorker4 = new JiJinBankWorker();
bankWorker4.operation();
}
}
当需求变化时，不是修改原来代码，而是通过添加代码实现。这样，程序的扩展性好，也易于维护和升级，而具体想要达到这样的效果，需要使用接口和抽象类：将那些无法封闭的变化抽象出来，进行隔离，允许拓展。
开放封闭原则的优越性：
1.通过扩展已有的软件系统，可以提供新的行为，以满足对软件的新需求，使变化中的软件有一定的适应性和灵活性。
2.已有的软件模块，特别是最重要的抽象模块不能再修改，这就使变化中的软件系统有一定的稳定性和延续性。
二、单一职责原则（single resposibility principle）
就一个类而言，应该仅有一个引起它变化的原因。
每一个职责都是一个变化的轴线，当需求变化时会反映为类的职责的变化。如果一个类承担的职责多于一个，那么引起它变化的原因就有多个。一个职责的变化甚至可能会削弱或者抑制类完成其他职责的能力，从而导致脆弱的设计。像山寨手机，有很多功能，如拍照、摄像、手机游戏、网络摄像头、GPS、炒股等等。虽然功能多，但是每一个功能都不强。
如果一个类里面有各种各样的代码，什么算法、数据库访问之类的都写在一起，这样无论任何需求要来，都需要更改这个类，维护麻烦，复用不可能，也缺乏灵活性。
例子：接受客户端输入并提交到数据库。
原有设计：
一个类负责接受客户端输入，对客户端输入进行校验，连接数据库，并提交数据到数据库。
import java.util.Scanner;
public class SaveToDB {
private String username;
private String upassword;
//获得客户端输入
public void shuru() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名");
username = scanner.nextLine();
System.out.println("请输入密码");
upassword = scanner.nextLine();
}
//进行数据校验
public boolean validate() {
if(username == null || "".equals(username.trim())) {
//trim()方法删除字符串起始和结尾的空格，返回调用字符串对象的一个副本
System.out.println("用户名不能为空");
return false;
}
if(upassword == null || "".equals(upassword.trim())) {
System.out.println("密码不能为空");
return false;
}
return true;
}
//连接数据库
public void getConnection() {
System.out.println("获得数据库连接");
}
//进行数据操作
public void save() {
System.out.println("将" + username + "保存到了数据库");
System.out.println("将" + upassword + "保存到了数据库");
}
}
import java.util.Scanner;
public class MainClass {
public static void main(String[] args) {
//接受客户端的输入
SaveToDB std = new SaveToDB();
std.shuru();
if(std.validate()) {
std.getConnection();
std.save();
}
}
}
现有设计：
一个功能也就是一个职责由一个类来负责。
import java.util.Scanner;
public class Input {
private String username;
private String upassword;
//获得客户端输入
public void shuru() {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入用户名");
username = scanner.nextLine();
System.out.println("请输入密码");
upassword = scanner.nextLine();
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getUpassword() {
return upassword;
}
public void setUpassword(String upassword) {
this.upassword = upassword;
}
}
public class Validator {
//进行数据校验
public boolean validate(String username, String upassword) {
if(username == null || "".equals(username.trim())) {
System.out.println("用户名不能为空");
return false;
}
if(upassword == null || "".equals(upassword.trim())) {
System.out.println("密码不能为空");
return false;
}
return true;
}
}
public class DBManager {
//连接数据库
public static void getConnection() {
System.out.println("获得数据库连接");
}
}
public class DAOImp {
//进行数据操作
public void save(String username,String upassword) {
System.out.println("将" + username + "保存到了数据库");
System.out.println("将" + upassword + "保存到了数据库");
}
}
public class MainClass {
public static void main(String[] args) {
Input input = new Input();
input.shuru();
Validator validator = new Validator();
if(validator.validate(input.getUsername(), input.getUpassword())){
DBManager.getConnection();
DAOImp dao = new DAOImp();
dao.save(input.getUsername(), input.getUpassword());
}
}
}
三、里氏代换原则（Liskov substitution principle）
里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化，而里氏代换原则是对实现抽象化的具体步骤的规范。
LSP是继承复用的基石，一个软件实体如果使用的是一个基类的话，那么一定适用于其子类，而且察觉不出基类和子类对象的区别。也就是说，在软件里面，把基类替换成它的子类，程序的行为没有变化，软件单位的功能不会受到影响。这样基类才能真正被复用，而子类也能够在基类的基础上增加新的行为。但是，反过来的代换不成立，也就是说，一个软件实体如果使用的是一个子类的话，那么它不能适用于其基类。
例子1：人和男人
public class Person {
public void display() {
System.out.println("this is a person");
}
}
public class Man extends Person {
public void display() {
System.out.println("this is a man");
}
}
public class MainClass {
public static void main(String[] args) {
Person person = new Person();
display(person);
Man man = new Man();
display(man);
}
public static void display(Person person) {
person.display();
}
}
显然，方法display既适用于父类Person，又适用于子类Man。但如果将方法display(Person person)修改为以下形式，只能接受子类Man。
public static void display(Man person) {
person.display();
}
例子2：长方形和正方形
长方形有两个属性：width height；正方形有一个属性：side。正方形不是长方形的子类，可以将他们看成两个独立的类。
如果我们强制正方形继承长方形，
public class ChangFX {
private long width;
private long height;
public long getWidth() {
return width;
}
public void setWidth(long width) {
this.width = width;
}
public long getHeight() {
return height;
}
public void setHeight(long height) {
this.height = height;
}
}
public class ZhengFX implements ChangFX{
private long side;
public long getHeight() {
return this.getSide();
}
public long getWidth() {
return this.getSide();
}
public void setHeight(long height) {
this.setSide(height);
}
public void setWidth(long width) {
this.setSide(width);
}
public long getSide() {
return side;
}
public void setSide(long side) {
this.side = side;
}
}
public class MainClass {
public static void main(String[] args) {
ChangFX changfx = new ChangFX();
changfx.setHeight(10);
changfx.setWidth(20);
test(changfx);
ZhengFX zhengfx = new ZhengFX();
zhengfx.setHeight(10);
zhengfx.setWidth(20);
test(zhengfx);
}
public static void test(ChangFX changfx) {
System.out.println(changfx.getHeight());
System.out.println(changfx.getWidth());
}
}
这样骗过了java编译器，但是上述定义的长方形和正方形并不是真的符合里氏代换原则，不妨在MainClass中增加下面方法，程序会陷入死循环中。
public static void resize(Changfx changfx) {
while(changfx.getHeight() <= changfx.getWidth()) {
changfx.setHeight(changfx.getHeight() + 1);
test(changfx);
}
}
如果我们构造一个抽象的四边形类，里面只有取width和height的抽象方法，没有对width和height赋值的方法，让长方形和正方形都是四边形的子类，这样LSP就不会被破坏。
public interface Sibianxing {
public long getWidth();
public long getHeight();
}
public class ChangFX implements Sibianxing{
private long width;
private long height;
public long getWidth() {
return width;
}
public void setWidth(long width) {
this.width = width;
}
public long getHeight() {
return height;
}
public void setHeight(long height) {
this.height = height;
}
}
public class ZhengFX implements Sibianxing{
private long side;
public long getHeight() {
return this.getSide();
}
public long getWidth() {
return this.getSide();
}
public void setHeight(long height) {
this.setSide(height);
}
public void setWidth(long width) {
this.setSide(width);
}
public long getSide() {
return side;
}
public void setSide(long side) {
this.side = side;
}
}
public class MainClass {
public static void main(String[] args) {
ChangFX changfx = new ChangFX();
changfx.setHeight(10);
changfx.setWidth(20);
test(changfx);
ZhengFX zhengfx = new ZhengFX();
zhengfx.setHeight(10);
test(zhengfx);
}
public static void test(Sibianxing sibianxing) {
System.out.println(sibianxing.getHeight());
System.out.println(sibianxing.getWidth());
}
}
例子3：鸟和企鹅
public interface Bird {
public void fly();
}
public class Laoying implements Bird {
public void fly() {
System.out.println("老鹰在飞");
}
}
public class Maque implements Bird {
public void fly() {
System.out.println("麻雀在飞");
}
}
public class Qie{
public void fly(){
//企鹅不会飞
}
}
public class MainClass {
public static void main(String[] args) {
fly(new Laoying());
fly(new Maque());
fly(new Qie());
}
public static void fly(Bird bird) {
bird.fly();
}
}
可以看到企鹅虽然属于鸟类，但并不会飞，不必强求它实现上述定义的Bird接口。这里的企鹅和鸟之间不存在里氏代换原则。
四、依赖倒转原则（dependency inversion principle）
传统的过程式设计倾向于使高层次的模块依赖于低层次的模块，抽象层依赖于具体层
倒转后：
依赖倒转是开-闭原则的基础，具体内容是：
1.抽象不应该依赖于细节（具体），细节（具体）应该依赖于抽象。
2.高层模块不依赖底层模块，两者都依赖抽象。
例子： 组装电脑
/*
* 主板抽象类
*/
public abstract class MainBoard {
public abstract void doSomething();
}
/*
* 华硕主板
*/
public class HuaShuoMainBoard extends MainBoard{ public void doSomething() {
System.out.println("this is huashuoMainBoard");
}
}
/*
* 微星主板
*/
public class WeiXingMainBoard extends MainBoard { public void doSomething() {
System.out.println("this is weixingMainBoard");
} }
/*
* 硬盘的抽象类
*/
public abstract class HardDisk {
public abstract void doSomething();
}
/*
* 希捷硬盘
*/
public class XiJieHardDisk extends HardDisk { public void doSomething() {
System.out.println("this is xijieHardDisk");
}
}
/*
* 西数硬盘
*/
public class XiShuHardDisk extends HardDisk { public void doSomething() {
System.out.println("this is xishuHardDisk");
}
}
/*
* 内存的抽象类
*/
public abstract class Memory {
public abstract void doSomething();
}
/*
* 金士顿内存
*/
public class JinShiDunMemory extends Memory { public void doSomething() {
System.out.println("this is jinshidunMemory");
}
}
/*
* 金邦内存
*/
public class JinBangMemory extends Memory { public void doSomething() {
System.out.println("this is jinbangMemory");
}
}
/*
* 电脑
*/
public class Computer {
private MainBoard mainBoard;
private Memory memory;
private HardDisk harddisk; public MainBoard getMainBoard() {
return mainBoard;
} public void setMainBoard(MainBoard mainBoard) {
this.mainBoard = mainBoard;
} public Memory getMemory() {
return memory;
} public void setMemory(Memory memory) {
this.memory = memory;
} public HardDisk getHarddisk() {
return harddisk;
} public void setHarddisk(HardDisk harddisk) {
this.harddisk = harddisk;
} public void display() {
mainBoard.doSomething();
memory.doSomething();
harddisk.doSomething();
}
}
public class MainClass {
public static void main(String[] args) {
Computer computer = new Computer();
computer.setMainBoard(new HuaShuoMainBoard());
computer.setMemory(new JinShiDunMemory());
computer.setHarddisk(new XiJieHardDisk());
computer.display();
System.out.println("-------------");
computer.setMainBoard(new WeiXingMainBoard());
computer.display();
}
}
如果将Computer类改为下列形式，主要是违背了第二条，高层次模块依赖于低层次模块。
public class Computer {
private HuaShuoMainBoard mainBoard;
private JinShiDunMemory memory;
private XiJieHardDisk harddisk;
public HuaShuoMainBoard getMainBoard() {
return mainBoard;
}
public void setMainBoard(HuaShuoMainBoard mainBoard) {
this.mainBoard = mainBoard;
}
public JinShiDunMemory getMemory() {
return memory;
}
public void setMemory(JinShiDunMemory memory) {
this.memory = memory;
}
public XiJieHardHardDisk getHarddisk() {
return harddisk;
}
public void setHarddisk(XiJieHardHardDisk harddisk) {
this.harddisk = harddisk;
}
public void display() {
mainBoard.doSomething();
memory.doSomething();
harddisk.doSomething();
}
}
在工厂方法模式、模板方法模式、迭代子模式中都有明显的依赖倒转。
五、迪米特法则（law of Demeter）
迪米特法则最初是用来作为面向对象的系统设计风格的一种法则，于1987年秋天由lan holland在美国东北大学为一个叫做迪米特的项目设计提出的。 迪米特法则(Law of Demeter )又叫做最少知识原则，也就是说，一个对象应当对其他对象尽可能少的了解，应可能少的与其他对象发生相互作用，使得系统功能模块相对独立。在类的结构设计上，每一个类都应当尽量降低成员的访问权限。
迪米特法则： 如果两个类不必彼此直接通信，那么这两个类就不应当发生直接的相互作用。如果其中一个类需要调用另一类的某一个方法的话，可以通过第三者转发这个调用。其根本思想是强调了类之间的耦合性。类之间的耦合越弱，越有利于复用，一个处于弱耦合的类被修改，不会对有关系的类造成波及。
例子：不要和陌生人说话
这里，“某人”没有通过“朋友”，而是直接和“陌生人”联系了
public class SomeOne {
public void play(Friend friend){
System.out.println("someone play");
friend.play();
}
public void play(Stranger stranger) {
System.out.println("someone play");
stranger.play();
}
}
public class Friend {
public void play(){
System.out.println("friends paly");
}
}
public class Stranger {
public void play(){
System.out.println("stranger play");
}
}
public class MainClass {
public static void main(String[] args) {
SomeOne zhangsan = new SomeOne();
zhangsan.play(new Friend());
zhangsan.play(new Stranger());
}
}
“某人”通过“朋友”和“陌生人”联系
public class SomeOne {
public void play(Friend friend){
System.out.println("someone play");
friend.play();
Stranger stranger = friend.getStranger();
stranger.play();
}
}
public class Friend {
public void play(){
System.out.println("friends paly");
}
public Stranger getStranger() {
return new Stranger();
}
}
public class Stranger {
public void play(){
System.out.println("stranger play");
}
}
public class MainClass {
public static void main(String[] args) {
SomeOne zhangsan = new SomeOne();
zhangsan.play(new Friend());
}
}
在SomeOne类中还有Stranger，而且“某人”和“朋友”的关系设置也不太合理，继续修改为：
public class SomeOne {
private Friend friend;
public Friend getFriend() {
return friend;
}
public void setFriend(Friend friend) {
this.friend = friend;
}
public void play(Friend friend){
System.out.println("someone play");
friend.play();
}
}
public class Friend {
public void play(){
System.out.println("friends paly");
}
public void playWithStranger() {
Stranger stranger = new Stranger();
stranger.play();
}
}
public class Stranger {
public void play(){
System.out.println("stranger play");
}
}
public class MainClass {
public static void main(String[] args) {
SomeOne zhangsan = new SomeOne();
zhangsan.setFriend(new Friend());
zhangsan.getFriend().playWithStranger();
}
}
在外观模式和终结者模式中，迪米特法则很明显。
6、接口隔离法则(Interface Segregation Principle）
客户端不应该依赖那些它不需要的接口；一个类对另一个类的依赖应该建立在最小的接口上。
如下图所示，类A依赖接口I中的方法1、方法2、方法3，类B是对类A依赖的实现。类C依赖接口I中的方法1、方法4、方法5，类D是对类C依赖的实现。对于类B和类D来说，虽然他们都存在着用不到的方法（也就是图中红色字体标记的方法），但由于实现了接口I，所以也必须要实现这些用不到的方法。
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());
}
}
我们需要将臃肿的接口I拆分为独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系，也就是采用接口隔离原则，如下所示。
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");
}
}
接口隔离原则的含义是：建立单一接口，不要建立庞大臃肿的接口，尽量细化接口，接口中的方法尽量少。也就是说，我们要为各个类建立专用的接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。
接口是设计时对外部设定的“契约”，通过分散定义多个接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
采用接口隔离原则对接口进行约束时，要注意以下几点：
- 接口尽量小，但是要有限度。对接口进行细化可以提高程序设计灵活性是不挣的事实，但是如果过小，则会造成接口数量过多，使设计复杂化。所以一定要适度。
- 为依赖接口的类定制服务，只暴露给调用的类它需要的方法，它不需要的方法则隐藏起来。只有专注地为一个模块提供定制服务，才能建立最小的依赖关系。
- 提高内聚，减少对外交互。使接口用最少的方法去完成最多的事情。
7 .合成/聚合复用原则(Composite/Aggregate Reuse Principle)
这个原则涉及到为聚合(Aggregation) 关系和合成(Composition) 关系，在“设计模式--UML类图”中有所介绍。
这个原则指复用时要尽量使用合成/聚合关系（关联关系），少用继承。
通过继承来进行复用的主要问题在于继承复用会破坏系统的封装性，因为继承会将基类的实现细节暴露给子类，由于基类的内部细节通常对子类来说是可见的，所以这种复用又称“白箱”复用，如果基类发生改变，那么子类的实现也不得不发生改变；从基类继承而来的实现是静态的，不可能在运行时发生改变，没有足够的灵活性；而且继承只能在有限的环境中使用（如类没有声明为不能被继承）。
由于组合或聚合关系可以将已有的对象（也可称为成员对象）纳入到新对象中，使之成为新对象的一部分，因此新对象可以调用已有对象的功能，这样做可以使得成员对象的内部实现细节对于新对象不可见，所以这种复用又称为“黑箱”复用，相对继承关系而言，其耦合度相对较低，成员对象的变化对新对象的影响不大，可以在新对象中根据实际需要有选择性地调用成员对象的操作；合成复用可以在运行时动态进行，新对象可以动态地引用与成员对象类型相同的其他对象。
总之，合成/聚合可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。使用继承要严格遵循里氏代换原则，有效使用继承会有助于对问题的理解，降低复杂度，但滥用继承反而会增加系统构建和维护的难度以及系统的复杂度，因此需要慎重使用继承复用。
如果两个类之间是“Has-A”的关系应使用合成或聚合，如果是“Is-A”关系可使用继承。"Is-A"是严格的分类学意义上的定义，意思是一个类是另一个类的"一种"；而"Has-A"则不同，它表示某一个角色具有某一项责任。
例子：我们需要办理一张银行卡，如果银行卡默认都拥有了存款、取款和透支的功能，那么我们办理的卡都将具有这个功能，此时使用了继承关系：
为了灵活地拥有各种功能，此时可以分别设立储蓄卡和信用卡两种，并有银行卡来对它们进行聚合使用。此时采用了合成复用原则:
