[toc]
设计模式的目的：
代码的重用性(相同的代码，不用多次编写)可读性（编程规范，便于其他程序员的阅读和理解）可扩展性（当增加新的功能时，非常方便）可靠性（新增功能后，对原来的功能没有影响）使程序呈现高内聚、底耦合的特性（模块与模块之间互不依赖、模块内部高度聚合） 设计模式：包含了面向对象的精髓开闭原则（Open-Closed Principle, OCP）是指一个软件实体如类、模块和函数应该对扩展开放，对修改关闭。所谓的开闭，也正是对扩展和修改两个行为的一个原则。强调的是用抽象构建框架，用实现扩展细节。可以提高软件系统的可复用性及可维护性。开闭原则，是面向对象设计中最基础的设计原则。它指导我们如何建立稳定灵活的系统，例如：我们版本更新，我尽可能不修改源代码，但是可以增加新功能。
实现开闭原则的核心思想就是面向抽象编程：
代码实现：
/** * 课程接口 */ public interface ICource { Integer getId(); String getName(); Double getPrice(); } /** * Java 课程 */ public class JavaCource implements ICource { private Integer id; private String name; private Double price; @Override public Integer getId() { return id; } @Override public String getName() { return null; } @Override public Double getPrice() { return null; } public void setId(Integer id) { this.id = id; } public void setName(String name) { this.name = name; } public void setPrice(Double price) { this.price = price; } public JavaCource(Integer id, String name, Double price) { this.id = id; this.name = name; this.price = price; } } /** * 针对打折扩展的类 */ public class JavaDiscountCource extends JavaCource { /** * 重写父类的构造器 * @param id * @param name * @param price */ public JavaDiscountCource(Integer id, String name, Double price) { super(id, name, price); } /** * 获取原始价格 * @return */ public Double getOriginPrice() { return super.getPrice(); } /** * 获取打折后的价格 * @return */ public Double getPrice() { return super.getPrice() * 0.61; } }依赖倒置原则（Dependence Inversion Principle,DIP）是指设计代码结构时，高层模块（PythonCource）不应该依赖底层（Tom模）块，二者都应该依赖其抽象（ICource）。抽象不应该依赖细节；细节应该依赖抽象。通过依赖倒置，可以减少类与类之间的耦合性，提高系统的稳定性，提高代码的可读性和可维护性，并能够降低修改程序所造成的风险。
依赖倒置：细节（PythonCource）依赖抽象（ICourse），而抽象不依赖细节，底层
/** * 抽象 ICourse 接口 */ public interface ICourse { void study(); } /** * 底层Tom模块 */ public class Tom { private ICourse course; public void study(){ course.study(); } public void setCourse(ICourse course) { this.course = course; } public ICourse getCourse() { return course; } } /** * 高层模块 扩展的PythonCourse */ public class PythonCource implements ICourse { @Override public void study() { System.out.println("Tom 在学习Python课程"); } } /** * 高层模块 扩展的JavaCourse */ public class JavaCource implements ICourse { @Override public void study() { System.out.println("Tom 在学习Java课程"); } } /** * 高层调用 */ public class ExeDemo { public static void main(String[] args) { JavaCource javaCource = new JavaCource(); Tom tom = new Tom(); tom.setCourse(javaCource); tom.study(); PythonCource pythonCource = new PythonCource(); tom.setCourse(pythonCource); tom.study(); } }依赖关系传递的三种关系：
1. 接口传递实现依赖 //开关的接口 interface IOpenAndClose{ public void open(ITV tv); } //ITV接口 interface ITV{ public void play(); } //实现接口 public class OpenAndClose implements IOpenAndClose{ public void open(ITV tv){ tv.play(); } } 构造方法传递 public OpenAndClose(ITV tv) //开关的接口 interface IOpenAndClose{ public void open(); } //ITV接口 interface ITV{ public void play(); } //实现接口 public class OpenAndClose implements IOpenAndClose{ private ITV tv; public OpenAndClose(ITV tv){ this.tc=tv; } public void open(){ this.tv.play(); } } setter方式传递 setITV(ITV tv) //开关的接口 interface IOpenAndClose{ public void open(); public void setITV(ITV tv); } //ITV接口 interface ITV{ public void play(); } //实现接口 public class OpenAndClose implements IOpenAndClose{ private ITV tv; public setITV(ITV tv){ this.tc=tv; } public void open(){ this.tv.play(); } }依赖倒转原则的注意事项和细节
底层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好变量的申明类型尽量是抽象类或者接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序的扩展和优化。继承时遵循里氏替换原则。单一职责（Simple Responsibility Pinciple，SRP）是指不要存在多于一个导致类变更的原因。假设我们有一个 Class 负责两个职责，一旦发生需求变更，修改其中一个职责的逻辑代码，有可能会导致另一个职责的功能发生故障。这样一来，这个 Class 存在两个导致类变更的原因。如何解决这个问题呢？我们就要给两个职责分别用两个 Class 来实现，进行解耦。后期需求变更维护互不影响。这样的设计，可以降低类的复杂度，提高类的可 读 性 ， 提 高 系 统 的 可 维 护 性 ， 降 低 变 更 引 起 的 风 险 。 总 体 来 说 就 是 一个class/Interface/Method 只负责一项职责。
用课程举例:
课程有直播课和录播课,直播课不能快进和快退,录播可以可以任意的反复观看，功能职责不一样。业务继续发展，课程要做权限。没有付费的学员可以获取课程基本信息，已经付费的学员可以获得视频流，即学习权限。那么对于控制课程层面上至少有两个职责。我们可以把展示职责和管理职责分离开来，都实现同一个抽象依赖。设计一个顶层接口,创建 ICourse 接口：
public interface ICourse { //获得基本信息 String getCourseName(); //获得视频流 byte[] getCourseVideo(); //学习课程 void studyCourse(); //退款 void refundCourse(); }我们可以把这个接口拆成两个接口，创建一个接口ICourseInfo 和ICourseManager： ICourseInfo 接口：
public interface ICourseInfo { String getCourseName(); byte[] getCourseVideo(); }ICourseManager 接口：
public interface ICourseManager { void studyCourse(); void refundCourse(); }LiveCourseImpl 实现类
public class LiveCourseImpl implements ICourseManager, ICourseInfo { @Override public String getCourseName() { return "直播课"; } @Override public byte[] getCourseVideo() { return new byte[0]; } @Override public void studyCourse() { System.out.println(getCourseName()+"直播课不能快进看"); } @Override public void refundCourse() { } }ReplayCourseImpl 实现类
public class ReplayCourseImpl implements ICourseManager, ICourseInfo { @Override public String getCourseName() { return "直播课"; } @Override public byte[] getCourseVideo() { return new byte[0]; } @Override public void studyCourse() { System.out.println(getCourseName()+"录播课可以反复回"); } @Override public void refundCourse() { } }单一职责原则注意事项和细节：
1. 低类的复杂性，一个类只负责一项职责。 2. 提高类的可读性、可维护性。 3. 降低变更引起的风险。 4. 通常情况下，我们应当遵守单一原则，只有逻辑足够简单，才可以在代码级别违背单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则。接口隔离原则（Interface Segregation Principle, ISP）是指用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口。这个原则指导我们在设计接口时应当注意一下几点： 1、一个类对一类的依赖应该建立在最小的接口之上。 2、建立单一接口，不要建立庞大臃肿的接口。 3、尽量细化接口，接口中的方法尽量少（不是越少越好，一定要适度）。 接口隔离原则符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性、可扩展性和可维护性。我们在设计接口的时候，要多花时间去思考，要考虑业务模型，包括以后有可能发生变更的地方还要做一些预判。所以，对于抽象，对业务模型的理解是非常重要的。下面我们来看一段代码，写一个动物行为的抽象：
IAnimal 接口：
public interface IAnimal { void eat(); void fly(); void swim(); }Bird 类实现：
public class Bird implements IAnimal { @Override public void eat() {} @Override public void fly() {} @Override public void swim() {} }Dog 类实现：
public class Dog implements IAnimal { @Override public void eat() {} @Override public void fly() {} @Override public void swim() {} }可以看出，Bird 的swim()方法可能只能空着，Dog 的fly()方法显然不可能的。这时候，我们针对不同动物行为来设计不同的接口，分别设计IEatAnimal，IFlyAnimal 和ISwimAnimal 接口，来看代码：
IEatAnimal 接口：
public interface IEatAnimal { void eat(); }IFlyAnimal 接口：
public interface IFlyAnimal { void fly(); }ISwimAnimal 接口：
public interface ISwimAnimal { void swim(); }Dog 只实现IEatAnimal 和ISwimAnimal 接口：
public class Dog implements ISwimAnimal,IEatAnimal { @Override public void eat() {} @Override public void swim() {} }迪米特原则（Law of Demeter LoD）是指一个对象应该对其他对象保持最少的了解，又叫最少知道原则（Least Knowledge Principle,LKP），尽量降低类与类之间的耦合。迪米特原则主要强调只和朋友交流，不和陌生人说话。出现在成员变量、方法的输入、输出参数中的类都可以称之为成员朋友类，而出现在方法体内部的类不属于朋友类。耦合的方式：依赖、关联、组合、聚合直接朋友：成员变量、方法参数、方法返回值中的类在来设计一个权限系统，Boss 需要查看目前发布到线上的课程数量。这时候，Boss要找到 TeamLeader 去进行统计，TeamLeader 再把统计结果告诉 Boss。接下来我们还是来看代码： Course 类：
public class Course { }TeamLeader 类：
public class TeamLeader { public void checkNumberOfCourses(List<Course> courseList){ System.out.println("目前已发布的课程数量是："+courseList.size()); } }Boss 类：
public class Boss { public void commandCheckNumber(TeamLeader teamLeader){ //模拟Boss 一页一页往下翻页，TeamLeader 实时统计 List<Course> courseList = new ArrayList<Course>(); for (int i= 0; i < 20 ;i ++){ courseList.add(new Course()); } teamLeader.checkNumberOfCourses(courseList); } }测试代码：
public static void main(String[] args) { Boss boss = new Boss(); TeamLeader teamLeader = new TeamLeader(); boss.commandCheckNumber(teamLeader); }写到这里，其实功能已经都已经实现，代码看上去也没什么问题。根据迪米特原则，Boss只想要结果，不需要跟Course 产生直接的交流。而TeamLeader 统计需要引用Course对象。Boss 和Course 并不是朋友，从下面的类图就可以看出来： 下面来对代码进行改造：
TeamLeader 类：
public class TeamLeader { public void checkNumberOfCourses(){ List<Course> courseList = new ArrayList<Course>(); for(int i = 0 ;i < 20;i++){ courseList.add(new Course()); } System.out.println("目前已发布的课程数量是："+courseList.size()); } }Boss 类：
public class Boss { public void commandCheckNumber(TeamLeader teamLeader){ teamLeader.checkNumberOfCourses(); } }再来看下面的类图，Course 和Boss 已经没有关联了。
迪米特法则注意事项和细节：
迪米特法则的核心是降低类之间的耦合由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低（对象间）耦合关系，并不是要求完全没有关系。里氏替换原则（Liskov Substitution Principle,LSP）是指如果对每一个类型为 T1 的对象 o1,都有类型为 T2 的对象 o2,使得以 T1 定义的所有程序 P 在所有的对象 o1 都替换成o2 时，程序 P 的行为没有发生变化，那么类型 T2 是类型 T1 的子类型。 定义看上去还是比较抽象，我们重新理解一下，可以理解为一个软件实体如果适用一个父类的话，那一定是适用于其子类，所有引用父类的地方必须能透明地使用其子类的对象，子类对象能够替换父类对象，而程序逻辑不变。根据这个理解，我们总结一下：引申含义：子类可以扩展父类的功能，但不能改变父类原有的功能。
1、子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。 2、子类中可以增加自己特有的方法。 3、当子类的方法重载父类的方法时，方法的前置条件（即方法的输入/入参）要比父类方法的输入参数更宽松。 4、当子类的方法实现父类的方法时（重写/重载或实现抽象方法），方法的后置条件（即方法的输出/返回值）要比父类更严格或相等。
在前面讲开闭原则的时候埋下了一个伏笔，我们记得在获取折后时重写覆盖了父类的getPrice()方法，增加了一个获取源码的方法 getOriginPrice()，显然就违背了里氏替换原则。我们修改一下代码，不应该覆盖 getPrice()方法，增加 getDiscountPrice()方法：
public class JavaDiscountCourse extends JavaCourse { public JavaDiscountCourse(Integer id, String name, Double price) { super(id, name, price); } public Double getDiscountPrice(){ return super.getPrice() * 0.61; } }使用里氏替换原则有以下优点：
1、约束继承泛滥，开闭原则的一种体现。 2、加强程序的健壮性，同时变更时也可以做到非常好的兼容性，提高程序的维护性、扩 展性。降低需求变更时引入的风险。
现在来描述一个经典的业务场景，用正方形、矩形和四边形的关系说明里氏替换原则，我们都知道正方形是一个特殊的长方形，那么就可以创建一个长方形父类Rectangle 类：
public class Rectangle { private long height; private long width; @Override public long getWidth() { return width; } @Override public long getLength() { return length; } public void setLength(long length) { this.length = length; } public void setWidth(long width) { this.width = width; } }创建正方形Square 类继承长方形：
public class Square extends Rectangle { private long length; public long getLength() { return length; } public void setLength(long length) { this.length = length; } @Override public long getWidth() { return getLength(); } @Override public long getHeight() { return getLength(); } @Override public void setHeight(long height) { setLength(height); } @Override public void setWidth(long width) { setLength(width); } }在测试类中创建resize()方法，根据逻辑长方形的宽应该大于等于高，我们让高一直自增，知道高等于宽变成正方形：
public static void resize(Rectangle rectangle) { while (rectangle.getWidth() >= rectangle.getHeight()) { rectangle.setHeight(rectangle.getHeight() + 1); System.out.println("width:" + rectangle.getWidth() + ",height:" + rectangle.getHeight()); } System.out.println("resize 方法结束" + "\nwidth:" + rectangle.getWidth() + ",height:" + rectangle.getHeight()); }测试代码：
public static void main(String[] args) { Rectangle rectangle = new Rectangle(); rectangle.setWidth(20); rectangle.setHeight(10); resize(rectangle); }运行结果： 发现高比宽还大了，在长方形中是一种非常正常的情况。现在我们再来看下面的代码，把长方形 Rectangle 替换成它的子类正方形 Square，修改测试代码：
public static void main(String[] args) { Square square = new Square(); square.setLength(10); resize(square); }这时候我们运行的时候就出现了死循环，违背了里氏替换原则，将父类替换为子类后，程序运行结果没有达到预期。因此，我们的代码设计是存在一定风险的。里氏替换原则只存在父类与子类之间，约束继承泛滥。我们再来创建一个基于长方形与正方形共同的抽象四边形 Quadrangle 接口：
public interface Quadrangle { long getWidth(); long getHeight(); }修改长方形Rectangle 类：
public class Rectangle implements Quadrangle { private long height; private long width; @Override public long getWidth() { return width; } public long getHeight() { return height; } public void setHeight(long height) { this.height = height; } public void setWidth(long width) { this.width = width; } }修改正方形类Square 类：
public class Square implements Quadrangle { private long length; public long getLength() { return length; } public void setLength(long length) { this.length = length; } @Override public long getWidth() { return length; } @Override public long getHeight() { return length; } }此时，如果我们把resize()方法的参数换成四边形Quadrangle 类，方法内部就会报错。因为正方形Square 已经没有了setWidth()和setHeight()方法了。因此，为了约束继承泛滥，resize()的方法参数只能用Rectangle 长方形。
合成复用原则（Composite/Aggregate Reuse Principle,CARP）是指尽量使用对象组合(has-a)/聚合(contanis-a)，而不是继承关系达到软件复用的目的。可以使系统更加灵活，降低类与类之间的耦合度，一个类的变化对其他类造成的影响相对较少。 继承我们叫做白箱复用，相当于把所有的实现细节暴露给子类。组合/聚合也称之为黑箱复用，对类以外的对象是无法获取到实现细节的。要根据具体的业务场景来做代码设计，其实也都需要遵循 OOP 模型。还是以数据库操作为例，先来创建 DBConnection 类：
public class DBConnection { public String getConnection(){ return "MySQL 数据库连接"; } }创建ProductDao 类：
public class ProductDao{ private DBConnection dbConnection; public void setDbConnection(DBConnection dbConnection) { this.dbConnection = dbConnection; } public void addProduct(){ String conn = dbConnection.getConnection(); System.out.println("使用"+conn+"增加产品"); } }这就是一种非常典型的合成复用原则应用场景。但是，目前的设计来说，DBConnection还不是一种抽象，不便于系统扩展。目前的系统支持 MySQL 数据库连接，假设业务发生变化，数据库操作层要支持 Oracle 数据库。当然，我们可以在 DBConnection 中增加对Oracle 数据库支持的方法。但是违背了开闭原则。其实，我们可以不必修改 Dao 的代码，将 DBConnection 修改为 abstract，来看代码：
public abstract class DBConnection { public abstract String getConnection(); }然后，将 MySQL 的逻辑抽离：
public class MySQLConnection extends DBConnection { @Override public String getConnection() { return "MySQL数据库连接"; } }再创建 Oracle 支持的逻辑：
public class OracleConnection extends DBConnection { @Override public String getConnection() { return "Oracle数据库连接"; } }具体选择交给应用层，来看一下类图： 设计原则总结:
学习设计原则，学习设计模式的基础。在实际开发过程中，并不是一定要求所有代码都遵循设计原则，我们要考虑人力、时间、成本、质量，不是刻意追求完美，要在适当的场景遵循设计原则，体现的是一种平衡取舍，帮助我们设计出更加优雅的代码结构。
