设计模式学习笔记

需要设计模式的例子：比如统一添加限制非会员查看一个月前日志的功能，核心代码都差不多，但每个接口传的字段名字、啥的都有区别。还有null等处理，时间戳与直接的时间的区别

工厂模式

介绍

使用场景：比如我们使用一个mysql类的方法，但是之后都要换成oracle，那么就有大量的重命名工作要去做。所以，将其变为“配置”的方式，改为db = DBFactory.get(‘Mysql’); 后续统一使用db这个变量即可。或者我们需要连接数据库但是每次都是写网址的模式，以后换起来很麻烦。就改成get(‘dev’)啊 之类的方式获取

应用实例： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

具体实现

步骤 1
创建一个接口:

Shape.java
public interface Shape {
   void draw();
}

步骤 2
创建实现接口的实体类。

Rectangle.java
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
Square.java
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
Circle.java
public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤 3
创建一个工厂，生成基于给定信息的实体类的对象。

ShapeFactory.java
public class ShapeFactory {
    
   //使用 getShape 方法获取形状类型的对象
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
}

步骤 4
使用该工厂，通过传递类型信息来获取实体类的对象。

FactoryPatternDemo.java
public class FactoryPatternDemo {
 
   public static void main(String[] args) {
      ShapeFactory shapeFactory = new ShapeFactory();
 
      //获取 Circle 的对象，并调用它的 draw 方法
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取 Rectangle 的对象，并调用它的 draw 方法
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
 
      //获取 Square 的对象，并调用它的 draw 方法
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
   }
}

步骤 5
执行程序，输出结果：

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.

具体实现转自 https://www.runoob.com/design-pattern/factory-pattern.html

实现总结：
1、一个抽象类，如DB class
2、编写若干个具体的继承类，重载去写DB class 的某方法 如getList
3、之后只需要声明继承类是啥 然后调用的方法都是一样的名字和参数

归纳：
简单工厂模式简而言之，就是有一个专门生产某个产品的类。再比如鼠标工厂，专业生产鼠标，给参数0，生产戴尔鼠标，给参数1，生产惠普鼠标。

进阶：戴尔、惠普也有不同的鼠标种类，我们加层级后就会变成这样
每一种品牌对应一个工厂子类，在创建具体键盘对象时，实例化不同的工厂子类。但是，如果业务涉及的子类越来越多，难道每一个子类都要对应一个工厂类吗？这样会使得系统中类的个数成倍增加，增加了代码的复杂度。

抽象工厂模式

我们现在有这么一个场景；现在用户的需求变多了，除了要求不同的形状之外，我们还要求创建不同颜色的形状，比如圆形，我们要求红色的圆形、赤橙黄绿青蓝紫等各种各样颜色的圆形。（实例就是QQ换皮肤 一整套一起换 还可能每套能调整颜色）

按照我们抽象方法模式的设计方案，那么我们就需要实现各种颜色的形状并实现这些颜色的形状对应的工厂类，这样一来我们系统中会增多非常多的工厂类。
比如:RedCircle、各种颜色的Circle类。
Red正方形类、各种颜色的正方形类……

而实际上，可以针对颜色单独搞一个“工厂” ，这样我们只需要两个工场就够了！然后 定义一个更上层的抽象工厂类，这个抽象工程包含颜色工厂和形状工厂两个工厂。

抽象工厂模式也就是不仅生产鼠标，同时生产键盘。
也就是PC厂商是个父类，有生产鼠标，生产键盘两个接口。
戴尔工厂，惠普工厂继承它，可以分别生产戴尔鼠标+戴尔键盘，和惠普鼠标+惠普键盘。
创建工厂时，由戴尔工厂创建。
后续工厂.生产鼠标()则生产戴尔鼠标，工厂.生产键盘()则生产戴尔键盘

上面新建pcfactory的时候 省略了 new对象时候传入的参数，或者省略了创造对象的方法

简单工厂 ： 用来生产同一等级结构中的任意产品。（对于增加新的产品，主要是新增产品，就要修改工厂类。符合单一职责原则。不符合开放-封闭原则）工厂方法 ：用来生产同一等级结构中的固定产品。（支持增加任意产品，新增产品时不需要更改已有的工厂，需要增加该产品对应的工厂。符合单一职责原则、符合开放-封闭原则。但是引入了复杂性）抽象工厂 ：用来生产不同产品族的全部产品。（增加新产品时，需要修改工厂，增加产品族时，需要增加工厂。符合单一职责原则，部分符合开放-封闭原则，降低了复杂性）

工厂方法模式的工厂是创建出一种产品，而抽象工厂是创建出一类产品。

建造者模式

参考：https://zhuanlan.zhihu.com/p/58093669
当一个类的构造函数参数个数超过4个，而且这些参数有些是可选的参数，考虑使用构造者模式。
当一个类的构造函数参数超过4个，而且这些参数有些是可选的时，我们通常有两种办法来构建它的对象。 例如我们现在有如下一个类计算机类Computer，其中cpu与ram是必填参数，而其他3个是可选参数，那么我们如何构造这个类的实例呢,通常有两种常用的方式：

public class Computer {
    private String cpu;//必须
    private String ram;//必须
    private int usbCount;//可选
    private String keyboard;//可选
    private String display;//可选
}

第一：折叠构造函数模式（telescoping constructor pattern ），这个我们经常用,如下代码所示

public class Computer {
     ...
    public Computer(String cpu, String ram) {
        this(cpu, ram, 0);
    }
    public Computer(String cpu, String ram, int usbCount) {
        this(cpu, ram, usbCount, "罗技键盘");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard) {
        this(cpu, ram, usbCount, keyboard, "三星显示器");
    }
    public Computer(String cpu, String ram, int usbCount, String keyboard, String display) {
        this.cpu = cpu;
        this.ram = ram;
        this.usbCount = usbCount;
        this.keyboard = keyboard;
        this.display = display;
    }
}

第二种：Javabean 模式，如下所示

public class Computer {
        ...

    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getRam() {
        return ram;
    }
    public void setRam(String ram) {
        this.ram = ram;
    }
    public int getUsbCount() {
        return usbCount;
    }
...
}

问题
(1)第一种实例化对象方式，需要编写不同的构造函数,在成员变量非常多的情况下需要根据可变的成员变量来编写大量不同的构造函数，灵活性较差，参数类型相似时实际调用时不方便。
(2)第二种实例化对象方式，属性的设置是分开的，代码复杂的情况下可能会出现设置属性遗漏或出错的情况（评论 这个痛点，用方法封装一下就好了，也不是必须用建造者模式才能解决）。

如何实现
在Computer 中创建一个静态内部类 Builder，然后将Computer 中的参数都复制到Builder类中。
在Computer中创建一个private的构造函数，参数为Builder类型
在Builder中创建一个public的构造函数，参数为Computer中必填的那些参数，cpu 和ram。
在Builder中创建设置函数，对Computer中那些可选参数进行赋值，返回值为Builder类型的实例
在Builder中创建一个build()方法，在其中构建Computer的实例并返回
下面代码就是最终的样子

public class Computer {
    private final String cpu;//必须
    private final String ram;//必须
    private final int usbCount;//可选
    private final String keyboard;//可选
    private final String display;//可选

    private Computer(Builder builder){
        this.cpu=builder.cpu;
        this.ram=builder.ram;
        this.usbCount=builder.usbCount;
        this.keyboard=builder.keyboard;
        this.display=builder.display;
    }
    public static class Builder{
        private String cpu;//必须
        private String ram;//必须
        private int usbCount;//可选
        private String keyboard;//可选
        private String display;//可选

        public Builder(String cup,String ram){
            this.cpu=cup;
            this.ram=ram;
        }

        public Builder setUsbCount(int usbCount) {
            this.usbCount = usbCount;
            return this;
        }
        public Builder setKeyboard(String keyboard) {
            this.keyboard = keyboard;
            return this;
        }
        public Builder setDisplay(String display) {
            this.display = display;
            return this;
        }        
        public Computer build(){
            return new Computer(this);
        }
    }
  //省略getter方法
}

如何使用
在客户端使用链式调用，一步一步的把对象构建出来。

Computer computer=new Computer.Builder("因特尔","三星")
                .setDisplay("三星24寸")
                .setKeyboard("罗技")
                .setUsbCount(2)
                .build();

以上方便理解，不是传统的建造者模式。详细看那个链接。
需要指出的是，由于java不支持默认参数，所以要这样设计。

首先你要明白，这些设计模式都是为了解决复业务代码才使用的，如果像demo这么简单的话反而是不用设计模式最好，效率最高。假设你这个对象要分好多步才能设置完成，这些设置步骤可能不在同一个类,设置的属性类型也比较复杂，你就容易漏掉其中几个，或者设置错其中几个状态。其他后来个新同事二狗，恨得的他默默骂你sb，因为他搞不明白你到底都在哪里不断地修改这个对象的状态…他也不管了，拿到你这个对象后又一通设置，后来又来个实习生牛翠花，更jb看不懂了，她也不管了，拿到这个对象再一通设置…最终的结果就是这个对象的状态现在是怎么样的已经没有人知道了…代码烂了，上帝保佑别出bug
终于懂了这个模式存在的意义，生产出来的对象就是个不可变对象

java也可通过这些方法设置默认值

void method(String p1, int p2, bool p3){
  // ....
};
void method(String p1, int p2){
  bool p3 = false;
  // ... 
};

但是有的时候如果参数太多，就不适合了。 （https://blog.csdn.net/weixin_33947521/article/details/91423853）

注：如数据库的操作，如果直接函数的形式，里面很多个参数，很容易不知道顺序，所以采取链式操作会好很多

单例模式

https://zhuanlan.zhihu.com/p/375538184

管道模式

https://zhuanlan.zhihu.com/p/62034262

门面模式

本文我们来学习一种新的结构型模式：门面模式。门面模式原理和实现都特别简单，应用场景也比较明确，主要在接口设计方面使用。

为了保证接口的可复用性（或者叫通用性），我们需要将接口尽量设计得细粒度一点，职责单一一点。但是，如果接口的粒度过小，在接口的使用者开发一个业务功能时，就会导致需要调用 n 多细粒度的接口才能完成。调用者肯定会抱怨接口不好用。

相反，如果接口粒度设计得太大，一个接口返回 n 多数据，要做 n 多事情，就会导致接口不够通用、可复用性不好。接口不可复用，那针对不同的调用者的业务需求，我们就需要开发不同的接口来满足，这就会导致系统的接口无限膨胀。

那如何来解决接口的可复用性（通用性）和易用性之间的矛盾呢？通过本文对于门面模式的学习，就会知道答案了

作者：舍是境界
链接：https://www.jianshu.com/p/4a5966659237
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

迭代器模式

背景

以学校院系展示为例，实现在一个页面展示学校的院系组成，一个学校有多个学院，一个学院有多个系。传统方式实现类图如下：

传统方式将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。实际上我们的要求是在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，而每个院对于系的存储方式各不相同（如数组、集合等），因此这种方案，不能很好实现的实现遍历操作。故引出迭代器模式。

概念

迭代器模式(Iterator Pattern)是常用的设计模式，属于行为型模式。如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决。

    迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即不暴露其内部的结构。

示例

java版

College接口，对学院进行抽象

public interface College {
    public String getName();
    //增加系的方法
    public void addDepartment(String name,String desc);
    //返回一个迭代器，遍历
    public Iterator createIterator();
}

     ComputerCollegeIterator类，实现Iterator接口，按数组方式实现hasNext, next, remove

public class ComputerCollegeIterator implements Iterator {
    //需要知道Department是以怎样的方式存放,此处为数组
    Department[] departments;
    int position = 0;
 
    public ComputerCollegeIterator(Department[] departments) {
        this.departments = departments;
    }
 
    @Override
    public boolean hasNext() {
        if (position >= departments.length || departments[position] == null) {
            return false;
        }
        return true;
    }
 
    @Override
    public Object next() {
        Department department = departments[position];
        position++;
        return department;
    }
 
    //默认空实现
    @Override
    public void remove() {
    }
}

ComputerCollege类，实现College接口，以数组形式存储系

public class ComputerCollege implements College{
    Department[] departments;
    int count = 0;//保存当前数组元素个数
 
    public ComputerCollege() {
       departments = new Department[5];
       addDepartment("JAVA","JAVA");
       addDepartment("C++","C++");
       addDepartment("Python","Python");
    }
 
    @Override
    public String getName() {
        return "计算机学院";
    }
 
    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name, desc);
        departments[count] = department;
        count++;
    }
 
    @Override
    public Iterator createIterator() {
        return new ComputerCollegeIterator(departments);
    }
}
         InfoCollegeIterator类，实现Iterator接口，按集合方式实现hasNext, next, remove

public class InfoCollegeIterator implements Iterator {
    List<Department> departments;
    int position = -1;
 
    public InfoCollegeIterator(List<Department> departments) {
        this.departments = departments;
    }
 
    @Override
    public boolean hasNext() {
        if (position >= departments.size()-1) {
            return false;
        }else {
            position++;
            return true;
        }
    }
 
    @Override
    public Object next() {
        Department department = departments.get(position);
        return department;
    }
 
    @Override
    public void remove() {
 
    }
}

     InfoCollege类，实现College接口，以集合形式存储系

public class InfoCollege implements College {
    List<Department> departments;
 
    public InfoCollege() {
        departments = new ArrayList<>();
        addDepartment("信息安全", "信息安全");
        addDepartment("网络安全", "网络安全");
    }
 
    @Override
    public String getName() {
        return "信息学院";
    }
 
    @Override
    public void addDepartment(String name, String desc) {
        Department department = new Department(name, desc);
        departments.add(department);
    }
 
    @Override
    public Iterator createIterator() {
        return new InfoCollegeIterator(departments);
    }
}

     OutPutImpl类，提供一个方法， 返回一个迭代器，该迭代器可以正确遍历集合，输出各个院系

public class OutPutImpl {
    //学院集合
    private List<College> collegeList;
 
    public OutPutImpl(List<College> collegeList) {
        this.collegeList = collegeList;
    }
 
    //遍历所有学院，然后调用printDepartment 输出各个学院的系
    public void printCollege(){
        Iterator<College> iterator = collegeList.iterator();
        while (iterator.hasNext()){
            College college = iterator.next();
            System.out.println("====="+college.getName()+"=======");
            printDepartment(college.createIterator());
        }
 
    }
 
    //输出系
    public void printDepartment(Iterator iterator){
        while (iterator.hasNext()){
            Department next = (Department) iterator.next();
            System.out.println(next.getName());
        }
    }
}

     Client类

public class Client {
    public static void main(String[] args) {
        ArrayList<College> colleges = new ArrayList<>();
        ComputerCollege computerCollege = new ComputerCollege();
        InfoCollege infoCollege = new InfoCollege();
        colleges.add(computerCollege);
        colleges.add(infoCollege);
 
        OutPutImpl outPut = new OutPutImpl(colleges);
        outPut.printCollege();
    }
}

输出结果

php版

迭代器有什么作用呢？

让对象变得可迭代并表现得像对象集合。

我们来看一道腾讯面试题

使对象可以像数组一样进行foreach循环，要求属性必须是私有。
这题其实就是考察到了迭代器了

我们先看看迭代器的接口

Iterator extends Traversable {
/* 方法 */
  abstract public current ( ) : mixed
  abstract public key ( ) : scalar
  abstract public next ( ) : void
  abstract public rewind ( ) : void
  abstract public valid ( ) : bool
}

里面定义了5个抽象方法

来看看最后的答案

class sample implements Iterator
{
    private $_items = array(1,2,3,4,5,6,7);
    public function __construct() {
    }
    //重置到到第一个元素
    public function rewind() { reset($this->_items); }
    //返回当前元素
    public function current() { return current($this->_items); }
    //返回当前元素到键 
    public function key() { return key($this->_items); }
    //返回下一个元素
    public function next() { return next($this->_items); }
    //检查当前元素是否有效
    public function valid() { return ( $this->current() !== false ); }
}
$sa = new sample();
foreach($sa as $key => $val){
    print $key . "=>" . $val;
}
//输出0=>1 1=>2 2=>3 3=>4 4=>5 5=>6 6=>7

我们通过foreach 遍历对象的时候，内部会依次调用

rewind() 重置到第一个元素
valid() 检查当前位置是否有效
current() 返回当前元素
key() 返回当前元素的键
next() 指向下一个元素

总结

1. 优点
   提供一个统一的方法遍历对象，客户不用再考虑聚合的类型，使用一种方法就可以遍历对象

    隐藏聚合的内部结构，客户端要遍历聚合的时候只能取到迭代器，而不会知道聚合的具体组成。
   
    提供了一种设计思想，就是一个类应该只有一个引起变化的原因(叫做单一责任原则)。在聚合类中，我们把迭代器分开，就是要把管理对象集合和遍历对象集合的责任分开，这样一来集合改变的话，只影响到聚合对象。而如果遍历方式改变的话，只影响到了迭代器。
   
    当要展示一组相似对象，或者遍历一组相同对象时使用，适合使用迭代器模式
   

2. 缺点
   每个聚合对象都要一个迭代器，会生成多个迭代器不好管理类
   ————————————————
   版权声明：本文为CSDN博主「枫陵」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
   原文链接：https://blog.csdn.net/weixin_43899792/article/details/124973499

生成器模式

似乎和php的生成器不一样
https://www.bilibili.com/read/cv16416349
https://www.ngui.cc/51cto/show-627191.html