设计模式七大原则

Java设计模式

设计模式的重要性

在软件工程中，设计模式（design pattern）是对软件实际中普遍存在（反复出现）的各种问题，所提出的解决方案。

使用了设计模式，软件具有很好的扩展性。

设计模式包含很多编程思想

设计模式的目的

1、代码重用性(相同功能的代码，不用多次编写)
2、可读性(编程的规范性，便于其他程序员的阅读和理解)
3、可扩展性(当需要增加新的功能时，非常方便，称为可维护性)
4、可靠性(当增加新的功能后，对原有的功能没有影响)
5、使程序呈现高内聚、低耦合的特征

设计模式七大原则

一句话概述七大原则

1、单一职责原则：一个类只负责一项职责

2、接口隔离原则：一个类只需要用到接口中的某一个方法，别的方法用不到时，拆分成多个接口

3、依赖倒置原则：面向接口编程

4、里氏替换原则：针对继承，在继承过程中，子类尽量不要重写父类的方法

5、开闭原则（ocp）：（对提供方而言）对扩展开放，（对使用方而言）对修改关闭

6、迪米特法则：我们称成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接朋友。也就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

7、合成复用原则：少用继承，多用合成/聚合

1、单一职责原则

基本介绍：

对于类来说，一个类应该只负责一项职责，如类A负责两个不同的原则：职责1、职责2。当职责1需求变更而改变A时，可能造成职责2执行错误，所以需要将类A的粒度分解为A1,A2。

职责不代表方法

案例

    package com.shejimoshi;

    public class SingleResponsibility {
      public static void main(String[] args) {
        Vehicle vehicle = new Vehicle();
        vehicle.run("出租车");
        vehicle.run("汽车");
        vehicle.run("飞机");
      }
    }
    // 交通工具类
    // 方案一
    // 1、在该方法中，违反了单一职责原则
    class Vehicle {
      public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
      }
    }
    // 方案二
    // 遵守了单一职责原则
    // 但是这样做的改动太大，即将类分解，同时修改客户端
    // 改进：直接修改Vehicle类，改动的代码会比较少
    class RoadVehicle {
      public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
      }
    }

    class AirVehicle {
      public void run(String vehicle) {
        System.out.println(vehicle + "在天空中运行。。。");
      }
    }

    class WaterVehicle {
      public void run(String vehicle) {
        System.out.println(vehicle + "在水中运行。。。");
      }
    }

    // 方案三
    // 这种修改方法没有对原来的类做大的修改，只是增加了方法
    // 这里虽然没有在类这个级别上遵守单一职责原则，但是在方法级别上，仍然遵守单一职责原则
    class Vehicle2 {
      public void run(String vehicle) {
        System.out.println(vehicle + "在公路上运行。。。");
      }

      public void runAir(String vehicle) {
        System.out.println(vehicle + "在天空中运行。。。");
      }

      public void runWater(String vehicle) {
        System.out.println(vehicle + "在水上运行。。。");
      }
    }

单一职责原则注意细节

1、降低类的复杂度，一个类只负责一项职责

2、提高类的可读性，可维护性

3、降低变更带来的风险

4、通常情况下，我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违反单一职责原则；只有类中方法足够少，可以在方法级别保持单一职责原则。

2、接口隔离原则

基本介绍

客户端不应该依赖它不需要的接口，即一个类对另一个类的依赖应该建立在最小的接口上。

一个接口有多个抽象方法，但是一个实体类只需要使用其实体类中几个方法，可以将几口拆分成多个接口。

案例

抛出问题

    public class Segregation1 {}

    interface Interface1 {
      void operation1();
      void operation2();
      void operation3();
      void operation4();
      void operation5();
    }

    class B implements Interface1 {
      @Override
      public void operation1() { System.out.println("B中实现了operation1"); }
      @Override
      public void operation2() { System.out.println("B中实现了operation2"); }
      @Override
      public void operation3() { System.out.println("B中实现了operation3"); }
      @Override
      public void operation4() { System.out.println("B中实现了operation4"); }
      @Override
      public void operation5() { System.out.println("B中实现了operation5"); }
    }

    class D implements Interface1 {
      @Override
      public void operation1() { System.out.println("D中实现了operation1"); }
      @Override
      public void operation2() { System.out.println("D中实现了operation2"); }
      @Override
      public void operation3() { System.out.println("D中实现了operation3"); }
      @Override
      public void operation4() { System.out.println("D中实现了operation4"); }
      @Override
      public void operation5() { System.out.println("D中实现了operation5"); }
    }

    class A { //通过接口Interface1依赖（使用）B类，但只会使用1，2，3方法
      public void depend1(Interface1 i){ i.operation1(); }
      public void depend2(Interface1 i){ i.operation2(); }
      public void depend3(Interface1 i){ i.operation3(); }
    }
    class C{//通过接口Interface1依赖（使用）D类，但只会使用1，2，5方法
      public void depend1(Interface1 i){ i.operation1(); }
      public void depend4(Interface1 i){ i.operation4(); }
      public void depend5(Interface1 i){ i.operation5(); }
    }

问题

类A通过接口Interface1依赖类B，类C通过接口Interface1依赖类D，如果接口Interface1对于类A和类C来说不是最小接口，那么类B和类D必须去实现他们不需要的方法！

改进

将接口Interface1拆分成独立的几个接口，类A和类C分别与他们需要的接口建立依赖关系。也就是采用接口隔离原则。

接口Interface1中出现的方法，根据实际情况拆分成三个接口。

代码实现：

    interface Interface1 {
      void operation1();
    }
    interface Interface2{
      void operation2();
      void operation3();
    }
    interface Interface3{
      void operation4();
      void operation5();
    }

    class B implements Interface1,Interface2 {
      @Override
      public void operation1() { System.out.println("B中实现了operation1"); }
      @Override
      public void operation2() { System.out.println("B中实现了operation2"); }
      @Override
      public void operation3() { System.out.println("B中实现了operation3"); }
    }

    class D implements Interface1,Interface3 {
      @Override
      public void operation1() { System.out.println("D中实现了operation1"); }
      @Override
      public void operation4() { System.out.println("D中实现了operation4"); }
      @Override
      public void operation5() { System.out.println("D中实现了operation5"); }
    }

    class A { //通过接口Interface1，Interface2依赖（使用）B类，但只会使用1，2，3方法
      public void depend1(Interface1 i){ i.operation1(); }
      public void depend2(Interface2 i){ i.operation2(); }
      public void depend3(Interface2 i){ i.operation3(); }
    }
    class C{//通过接口Interface1，Interface3依赖（使用）D类，但只会使用1，2，5方法
      public void depend1(Interface1 i){ i.operation1(); }
      public void depend4(Interface3 i){ i.operation4(); }
      public void depend5(Interface3 i){ i.operation5(); }
    }

3、依赖倒转(倒置)原则

基本概念

1、高层模块不应该依赖低层模块，二者都应该依赖其抽象

2、抽象不应该依赖细节，细节应该依赖抽象

3、依赖倒转（倒置）的中心思想是面向接口编程

4、依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定得多。以抽象为基础搭建的架构比以细节为基础的架构要稳定得多。在java中，抽象值得是接口或者抽象类，细节就是具体的实现类。

5、使用接口或者抽象类的目的是制定好规范，而不涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。

案例

    public class DependecyInversion {
      public static void main(String[] args) {
        Person person = new Person();
        person.recevie(new Email());
      }
    }

    class Email {
      public String getInfo() { return "电子邮件信息：hello,world"; }
    }
    // 完成Person接收消息的功能
    // 方式1
    //1、简单，比较容易想到
    //2、如果我们获取的对象是微信，短信等，则需要新增类，同时Person也要增加响应的接收方法
    //3、解决方法：引入一个抽象的接口IReceiver，表示接收者，这样Person类与接口IReceiver发生依赖
    // 因为Email，微信，短信等等都属于接受的范围，他们各自实现IReceiver接口就OK，这样就符合依赖倒转原则
    class Person {
      public void recevie(Email email) { System.out.println(email.getInfo()); }
    }

问题

如果我们获取的对象是微信，短信等，则需要新增类，同时Person也要增加响应的接收方法

改进

    public class DependecyInversion {
      public static void main(String[] args) {
        Person person = new Person();
        person.recevie(new Email());
      }
    }
    //定义一个接口
    interface IReceiver{ 
      String getInfo();
    }

    class Email implements IReceiver{
      @Override
      public String getInfo() { return "电子邮件信息：hello,world"; }
    }
    //增加微信
    class Weixin implements IReceiver{
      @Override
      public String getInfo() { return "微信信息：hello,world"; }
    }
    //方式2
    class Person {
      public void recevie(IReceiver receiver) { System.out.println(receiver.getInfo()); }
    }

依赖传递的三种方式

1、通过接口传递实现依赖

    interface ITv{//ITv接口
      void play();
    }
    interface IOpenAndClose{
      void open(ITv tv); //抽象方法，接收接口
    }
    //实现接口
    class OpenAndClose implements IOpenAndClose{
      @Override
      public void open(ITv tv) {
        tv.play();
      }
    }

2、通过构造方法依赖传递

    interface ITv{//ITv接口
      void play();
    }
    interface IOpenAndClose{
      void open(); //抽象方法
    }
    //实现接口
    class OpenAndClose implements IOpenAndClose{
      private ITv tv; //成员
      public OpenAndClose(ITv tv){ this.tv = tv; }//有参构造器
      @Override
      public void open() { tv.play(); }
    }

3、通过setter方法传递

    interface ITv{//ITv接口
      void play();
    }
    interface IOpenAndClose{
      void open(); //抽象方法
      void setTv(ITv tv); 
    }
    //实现接口
    class OpenAndClose implements IOpenAndClose{
      private ITv tv; //成员
      @Override
      public void open() { tv.play(); }

      @Override
      public void setTv(ITv tv) { this.tv = tv; }
    }

依赖倒转原则注意细节

1、低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好。

2、变量的声明类型尽量是抽象类或接口，这样我们的变量引用和实际对象间，就存在一个缓冲层，利于程序扩展和优化。

3、继承时遵循里氏替换原则

4、里氏替换原则 针对的是继承

oo中的继承性的思考和说明

1、继承包含这样一层含义：父类中凡是已经实现好的方法，实际上是在设定规范和契约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实现的方法任意修改，就会对整个继承体系造成破坏。

2、继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，则当这个类需要修改时，必须考虑所有的子类，并且父类修改后，所有涉及到子类的功能都有可能产生故障

3、问题提出：在编程中，如何正确的使用继承？=>里氏替换原则。

基本介绍

1、如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得T1定义的所有程序P在所有的对象o1都替换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1的子类型。换句话说，所有引用父类的地方必须能够透明地使用其子类的对象

2、在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法。

3、里氏替换原则告诉我们，继承实际上让两个类耦合性增强了，在适当的情况下，可以通过聚合，组合，依赖来解决问题。

案例

    public class Liskov {
      public static void main(String[] args) {
        A a = new A();
        System.out.println(a.fun1(11,3));
        System.out.println(a.fun1(1,8));

        System.out.println("================");
        B b = new B();
        System.out.println(b.fun1(11,3));
        System.out.println(b.fun1(1,8));
        System.out.println(b.fun2(11,3));
      }
    }

    class A {
      // 返回两个数的差
      public int fun1(int a, int b) {
        return a - b;
      }
    }

    //B类继承了A类
    //增加了一个新功能：完成两个数相加，然后和9求和
    class B extends A {
      @Override
      public int fun1(int a, int b) { //重写了fun1方法
        return a + b;
      }

      public int fun2(int a, int b) {
        return fun1(a, b) + 9;
      }
    }

解决方法

1、原来运行正常的相减功能发生了错误。原因是类B无意中重写了父类的方法，造成原有共功能出现错误。在实际编程中，我们常常会通过重写父类的方法完成新功能，这样写虽然简单，但整个继承体系的复用性会比较差。特别是运行多态比较频繁的时候

2、通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，采用依赖，聚合，组合等关系代替。

改进

    public class Liskov {
      public static void main(String[] args) {
        A a = new A();
        System.out.println(a.fun1(11,3));
        System.out.println(a.fun1(1,8));

        System.out.println("================");
        B b = new B();
        //因为B类不在继承A类，因此调用者，不会再fun1是求减法
        System.out.println(b.fun1(11,3));
        System.out.println(b.fun1(1,8));
        System.out.println(b.fun2(11,3));
      }
    }
    //创建一个更加基础的基类
    class Base{
      //把更加基础的方法和成员写道Base类中
    }
    class A extends  Base{
      // 返回两个数的差
      public int fun1(int a, int b) {
        return a - b;
      }
    }

    //B类继承了A类
    //增加了一个新功能：完成两个数相加，然后和9求和
    class B extends Base {
      //如果B需要使用到A类的方法，使用组合关系
      private A a = new A();
      //我们仍要使用A的方法
      public int fun3(int a,int b){
        return this.a.fun1(a,b);
      }

      public int fun1(int a, int b) { 
        return a + b;
      }

      public int fun2(int a, int b) {
        return fun1(a, b) + 9;
      }
    }

5、开闭原则(ocp原则)

基本介绍

1、开闭原则（Open Closed Principle）是编程中最基础，最重要的设计原则

2、一个软件间实体如类，模块和函数应该对扩展开放（对提供方来说），对修改关闭（对使用方来说）。用抽象构建框架，用实现扩展细节

3、当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已有的代码来实现变化。有需求变化是，尽量是新增功能，而不是修改已有功能

4、编程中遵循其他原则，以及使用设计模式的目的就是遵循开闭原则

案例

    public class Ocp {
        public static void main(String[] args) {

        }
    }
    class GraphicEditor{
        public void  drawShape(Shape s){
            if (s.m_type == 1){
                drawRectangle(s);
            }else if (s.m_type == 2){
                drawCircle(s);
            }//如果有新的需求，还得接着往后else if
        }
        //有新的需求，还得再写一个方法
        public void drawRectangle(Shape r){
            System.out.println("矩形");
        }
        public void drawCircle(Shape s){
            System.out.println("圆形");
        }
    }
    class Shape{
        int m_type;
    }
    class Rectangle extends Shape{
        Rectangle(){
            super.m_type = 1;
        }
    }
    class Circle extends Shape{
        Circle(){
            super.m_type = 2;
        }
    }

分析

优点：比较好理解，简单操作

缺点：违反了设计模式的ocp原则，即对扩展开放，对修改关闭。即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码

当我们要新增加一个图形种类，我们需要修改的地方比较多（在提供方添加了新的图形后，使用方需要额外新写一个新的方法，同时if判断也得加条件判断）

改进

思路：把Shape类做成抽象类，并提供一个draw方法，让子类实现即可，这样我们有新的图形种类时，只需要让新的图形继承Shape，并实现draw方法即可。

使用方的代码就不需要修改->满足了开闭原则

    public class Ocp {
        public static void main(String[] args) {

        }
    }

    class GraphicEditor {
        public void drawShape(Shape s) { s.draw(); }
    }

    abstract class Shape {
        public abstract void draw();
    }

    class Rectangle extends Shape {
        @Override
        public void draw() { System.out.println("矩形"); }
    }

    class Circle extends Shape {
        @Override
        public void draw() { System.out.println("圆形"); }
    }

6、迪米特法则

基本介绍

1、一个对象应该对其他对象保持最少的了解

2、类与类关系越密切，耦合度越大

3、迪米特法则又称为最少知道原则，即一个类对自己依赖的类知道的越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内部。对外除了提供public方法，不对外泄露任何信息

4、迪米特法则还有一个更简单的定义：只与直接的朋友通信

5、直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，我们就说这个两个对象之间是朋友关系。耦合的方式有很多，依赖，关联，组合，聚合等，其中，我们称成员变量，方法参数，方法返回值中的类为直接的朋友，而出现在局部变量中的类不是直接朋友。有就是说，陌生的类最好不要以局部变量的形式出现在类的内部。

案例

    public class Demeter {}
    // 公司总部员工类
    class Employee {
      private String id;
      public void setId(String id) { this.id = id; }
      public String getId() { return this.id; }
    }
    // 学院的员工类
    class CollegeEmployee {
      private String id;
      public void setId(String id) { this.id = id; }
      public String getId() { return this.id; }
    }
    // 管理学院员工的管理类
    class CollegeManager {
      public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
          CollegeEmployee emp = new CollegeEmployee();
          emp.setId("学院员工id=" + i);
          list.add(emp);
        }
        return list;
      }
    }
    // 学校管理类
    class ScoolMananager {
      public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
          Employee emp = new Employee();
          emp.setId("学校员工id=" + i);
          list.add(emp);
        }
        return list;
      }
      //该方法完成输出学校跟学院所有员工信息
      public void printAllEmployee(CollegeManager sub){
        //此处CollegeEmployee不是直接朋友，不属于成员变量，方法参数，方法返回值
        //是陌生类，违背了迪米特法则
        List<CollegeEmployee> allEmployee = sub.getAllEmployee();
        for (CollegeEmployee collegeEmployee : allEmployee) {
          System.out.println(collegeEmployee.getId());
        }

        List<Employee> allEmployee1 = this.getAllEmployee();
        for (Employee employee : allEmployee1) {
          System.out.println(employee.getId());
        }
      }
    }

改进

CollegeEmployee类在ScoolMananager类中不是直接朋友，不属于成员变量，方法参数，方法返回值是陌生类，违背了迪米特法则

    public class Demeter {}
    // 公司总部员工类
    class Employee {
      private String id;
      public void setId(String id) { this.id = id; }
      public String getId() { return this.id; }
    }
    // 学院的员工类
    class CollegeEmployee {
      private String id;
      public void setId(String id) { this.id = id; }
      public String getId() { return this.id; }
    }
    // 管理学院员工的管理类
    class CollegeManager {
      public List<CollegeEmployee> getAllEmployee() {
        List<CollegeEmployee> list = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
          CollegeEmployee emp = new CollegeEmployee();
          emp.setId("学院员工id=" + i);
          list.add(emp);
        }
        return list;
      }
      //增加此方法，将打印学院员工信息的程序写道CollegeManager类中
      // 在该类中CollegeEmployee类为直接朋友
      public void printEmployee(){
        List<CollegeEmployee> allEmployee = this.getAllEmployee();
        for (CollegeEmployee collegeEmployee : allEmployee) {
          System.out.println(collegeEmployee.getId());
        }
      }
    }
    // 学校管理类
    class ScoolMananager {
      public List<Employee> getAllEmployee() {
        List<Employee> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
          Employee emp = new Employee();
          emp.setId("学校员工id=" + i);
          list.add(emp);
        }
        return list;
      }
      //该方法完成输出学校跟学院所有员工信息
      public void printAllEmployee(CollegeManager sub){
        //此处直接调用
        sub.printEmployee();
        List<Employee> allEmployee1 = this.getAllEmployee();
        for (Employee employee : allEmployee1) {
          System.out.println(employee.getId());
        }
      }
    }

迪米塔法则注意细节

1、迪米特法则的核心是降低类之间的耦合

2、但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低类之间（对象之间）耦合关系，并不是要求完全没有依赖关系

7、合成复用原则

基本介绍

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

案例

    public class Composite {}
    class A {
      public void fun1() {}
      public void dun2() {}
    }
    //继承
    //如果我们只是让B类去使用A类中的某一个方法，使用继承会让B和A的耦合增强
    class B extends A{}
    //依赖
    //写一个方法，入参为A类对象
    class C{
      public void fun3(A a){}
    }
    //聚合
    //set方法
    class D {
      private A a;
      public void setA(A a){
        this.a = a;
      }
    }
    //组合
    //E创建了对象，A对象也创建了一个新的对象
    class E{
      private A a =new A();
    }

设计原则的核心思想

1、找出应用中可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混合在一起

2、针对接口编程，而不是针对实现编程

3、为了交互对象之间的松耦合设计而努力