设计模式

设计模式
接口
1、设计原则
2、创建模式
3、结构性模式
- 适配器模式
实现
4、行为形模式

设计模式（Design pattern）代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案

https://www.zhihu.com/question/305042684
面向过程的程序设计把计算机程序视为一系列的命令集合，即一组函数的顺序执行。为了简化程序设计，面向过程把函数继续切分为子函数，即把大块函数通过切割成小块函数来降低系统的复杂度。

OOP是组件化思想的一种体现，把对象作为程序的基本单元，~~将对象作为一个封装好的“积木”，~~屏蔽内部复杂性，对外暴露接口。与其他对象相互合作搭成一个程序。

二、AOP面向切面编程
也是一种编程思想，面对对象思想的一种补充，为分散的对象引入公共行为，植入增强代码，如给多个对象加事务和日志处理。主要是通过动态代理的方式实现。

接口

java中的接口就是一种公共规范标准，对外部约定的契约，定义接口就是在描述规范，实现接口就是在实现规范

接口是对类的行为的抽象，如人有打乒乓球，羽毛球等行为可以抽象为一个运动接口
抽象类是对类本身的抽象，接口是对类类行为的抽象，继承是不是，实现有没有。
抽象找相同，实现找不同。

定义：一种设计思想
在代码中体现：
在系统分析和架构中，分清层次和依赖关系，每个层次不是直接向其上层提供服务（即不是直接实例化在上层中），而是通过定义一组接口，仅向上层暴露其接口功能，上层对于下层仅仅是接口依赖，而不依赖具体类。

DIP原则
从业务角度来说
面向接口编程就是先把客户的业务提取出来，作为接口。业务具体实现通过该接口的实现类来完成。当客户需求变化时，只需编写该业务逻辑的新的实现类，通过更改配置文件(例如Spring框架)中该接口的实现类就可以完成需求，不需要改写现有代码，减少对系统的影响

ico和di ioc是目的，di是手段。ioc是指让生成对象的方式由传统方式（new）反过来，既程序员不调用new,需要类的时候由框架注入（di），是同一件不同层面的解读

一、IoC控制反转（IoC，Inversion of Control）

是一种编程思想。控制反转就是对对象控制权的转移，从程序代码本身反转到了外部容器。把对象的创建、初始化、销毁等工作交给spring容器来做。由spring容器控制对象的生命周期。即是将new 的过程交给spring容器去处理

例如：早上去早餐店买了一个包子，包子是早餐店做的，你通过钱买下了包子，包子的决定权就从早餐店转移到了你的手上。

二、DI依赖注入

依赖注入DI是指程序运行过程中，若需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部容器，由外部容器创建后传递给程序。依赖注入是目前最优秀的解耦方式。依赖注入让Spring的Bean之间以配置文件的方式组织在一起，而不是以硬编码的方式耦合在一起的。

控制反转(IoC)实际上是一种设计思想，一种软件设计目的，将类的依赖的控制权转移到第三方，如IOC容器,由第三方容器负责依赖对象的创建，初始化和注入。DI依赖注入，是一种手段，实现注入的一种手段。**DI是实现的IOC的一种手段**。例如想达到活着的目的你就要吃饭、喝水，你可以吃面条活着，也可以吃饭活着，活着就是你的目的，达到这个目的你要必须要吃，喝。DI是一种手段可以理解为吃饭，通过吃饭来达到活着的目的<br />![2021-02-03_220950.png](https://cdn.nlark.com/yuque/0/2021/png/12466223/1612361446573-daf5a4b7-8436-4f8e-8220-9bff0a9fce2d.png#height=558&id=k4joL&margin=%5Bobject%20Object%5D&name=2021-02-03_220950.png&originHeight=558&originWidth=1075&originalType=binary&ratio=1&size=16903&status=done&style=none&width=1075)

1、设计原则

1.1 开闭原则

定义

对拓展开放，对修改关闭。用抽象设计框架，用拓展实现细节

栗子一枚：

/**
 * 开闭原则   加拓展 不修改底层
 *
 * 如此时 有个课程打折的需求 此时该怎么做 ？
 *
 * 修改接口和修改JavaCourse这种偏底层的类或接口都可能导致其他问题，此时可以加拓展
 *
 * 此时该定义一个类继承JavaCourse类复写getPrice方法
 *
 *
 */
public class JavaCourse implements ICourse {
    private String name;
    private Integer id;
    private double price;
    public JavaCourse(String name, Integer id, double price) {
        this.name = name;
        this.id = id;
        this.price = price;
    }
    @Override
    public String getName() {
        return name;
    }
    @Override
    public Integer getId() {
        return id;
    }
    @Override
    public double getPrice() {
        return price;
    }
    @Override
    public String toString() {
        return "JavaCourse{" +
                "name='" + getName() + '\'' +
                ", id=" + getId() +
                ", price=" + getPrice() +
                '}';
    }
}
package com.lilei.design.principle.closeopen;
public class JavaDiscountCount extends JavaCourse {
    public JavaDiscountCount(String name, Integer id, double price) {
        super(name, id, price);
    }
    @Override
    public double getPrice() {
        return super.getPrice()*0.8;
    }
    @Override
    public String toString() {
        return "JavaDiscountCount{}"+super.toString();
    }
}

1.2 依赖倒置原则

定义

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

2.抽象不依赖细节；细节应该依赖抽象

3.针对接口编程，不要针对实现编程

上面定义不难理解，主要包含两次意思：

1）高层模块不应该直接依赖于底层模块的具体实现，而应该依赖于底层的抽象。换言之，模块间的依赖是通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或抽象类产生的。

2）接口和抽象类不应该依赖于实现类，而实现类依赖接口或抽象类。这一点其实不用多说，很好理解，“面向接口编程”思想正是这点的最好体现。

减少耦合

栗子一枚 Studyer并不直接依赖 JavaCourse PhpCourse这个两个底层类而是依赖其抽象

package com.lilei.design.principle.dependenceinversion;
public class Studyer {
    public void studyCourse(ICourse iCourse){
        iCourse.studyCourse();
    }
   /* public void studyJava(){
        System.out.println("studying java");
    }
    public void studyPhp(){
        System.out.println("studying php");
    }*/
}

1.3单一职责原则

定义

1、不要存在多于一个倒置类变更的原因

2、一个类/接口/方法只负责一项职责

优点，降低类的复杂度，提高类的可读性

方法的单一职责

package com.lilei.design.principle.singleresponsibility;
public class Work {
    //当出现这种情况则应该将其拆分为两个方法
    public void demoSingle(boolean bool){
        if (bool) {
            //todo something
        }
        else{
            //todo something
        }
    }
}

package com.lilei.design.principle.singleresponsibility;
public interface ICourse {
    // 当这个接口有两个职责时，则应该将其拆为两个接口
    void manageCourse();
    void studyCourse();
}

1.4接口隔离原则

定义：

用多个专门的接口而不是使用单一的总接口，客户端不应该依赖他不需要的接口

1.一个类对一个类的依赖应该建立在最小的接口上

2.建立单一接口，不要庞大的接口

3.尽量细化接口，接口中的方法尽量少

栗子一枚

package com.lilei.design.principle.interfacesegregation;
public interface IAnimalAction {
    void eat();
    void swim();
    void fly();
}

package com.lilei.design.principle.interfacesegregation;
/**
dog实现IAnimalAction接口但dog并不具备fly这个行为，所以这个就是一个空实现
在设计接口时要 尽量细化接口 保证准确性
*/
public class Dog implements IAnimalAction {
    @Override
    public void eat() {
    }
    @Override
    public void swim() {
    }
    @Override
    public void fly() {
    }
}

1.5最少知道原则

定义：一个对象应该对其他对象保持最少的了解

       尽量降低类的耦合

强调只和朋友交流，不和陌生人说话

朋友：出现在成员变量，方法的入参和出参的类称为朋友类，而出现在方法体内部的类不视为朋友类

package com.lilei.design.principle.demeter;
import java.util.ArrayList;
public class Boss {
    public void commandTeamLeader(TeamLeader teamLeader){
        teamLeader.selectCourse();
    }
}

package com.lilei.design.principle.demeter;
import java.util.ArrayList;
public class TeamLeader {
    public void selectCourse() {
        ArrayList<Course> list = new ArrayList<Course>();
        for (int i = 0; i < 20; i++) {
            list.add(new Course());
        }
        System.out.println(list.size());
    }
}

核心就是区分出朋友

2、创建模式

工厂模式

工厂模式模式一种创建对象的模式，它被广泛应用在jdk中以及Spring和Struts框架中；

1.简单工厂

由工厂对象决定创建哪一种对象，只要一个简单的参数

package com.lilei.design.pattern.creational.simplefactory;
public class VideoFactory {
    public Video makeVideo(Class<? extends Video> video){
        try {
            return video.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
        return null;
    }
}

2.工厂方法

定义
工厂方法模式基于”输入”，应用在超类和多个子类之间的情况，这种模式将创建对象的责任转移到工厂类；

定义：一个创建类的接口但让实现这个接口的类来决定实现那个类，工厂方法让类的实例化推迟到子类中进行

package com.lilei.design.pattern.creational.factorymethod;
public abstract class VideoFactory {
     // 类的实例化，推迟到子类来实现
     abstract Video makeVideo();
}

package com.lilei.design.pattern.creational.factorymethod;
public class PhpVideoFactory extends VideoFactory {
    @Override
    Video makeVideo() {
        return new PhpVideo();
    }
}

package com.lilei.design.pattern.creational.factorymethod;
public class JavaVideoFactory extends VideoFactory {
    @Override
    Video makeVideo() {
        return new JavaVideo();
    }
}
//===========================创建对象==============================
package com.lilei.design.pattern.creational.factorymethod;
public class Test {
    public static void main(String[] args){
        VideoFactory videoFactory = new JavaVideoFactory();
        Video video = videoFactory.makeVideo();
        video.play();
    }
}

当有新的类（和已知类处于同一产品等级）要被实例化时不用修改类，而是使用新加工厂的方式来创建，符合开闭原则，到也可能会导致类的数量过多

适用环境

一个类不知道它所需要的对象的类：在工厂方法模式中，客户端不需要知道具体产品类的类名，只需要知道所对应的工厂即可，具体的产品对象由具体工厂类创建；客户端需要知道创建具体产品的工厂类。
一个类通过其子类来指定创建哪个对象：在工厂方法模式中，对于抽象工厂类只需要提供一个创建产品的接口，而由其子类来确定具体要创建的对象，利用面向对象的多态性和里氏代换原则，在程序运行时，子类对象将覆盖父类对象，从而使得系统更容易扩展。
将创建对象的任务委托给多个工厂子类中的某一个，客户端在使用时可以无须关心是哪一个工厂子类创建产品子类，需要时再动态指定，可将具体工厂类的类名存储在配置文件或数据库中。

例子

package java.lang;
import java.util.Iterator;
import java.util.Objects;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.function.Consumer;
/**
 * Implementing this interface allows an object to be the target of the enhanced
 * {@code for} statement (sometimes called the "for-each loop" statement).
 *
 * @param <T> the type of elements returned by the iterator
 *
 * @since 1.5
 * @jls 14.14.2 The enhanced {@code for} statement
 */
public interface Iterable<T> {
    Iterator<T> iterator();
}

Iterable接口可以视为一个工厂方法的接口申明一个创建iterator实例的方法由实现类 ArrayList负责真正创建该实例

ArrayList
public Iterator<E> iterator() {
    return new Itr();
}
private class Itr implements Iterator<E> {
        /**
         * Index of element to be returned by subsequent call to next.
         */
        int cursor = 0;
        /**
         * Index of element returned by most recent call to next or
         * previous.  Reset to -1 if this element is deleted by a call
         * to remove.
         */
        int lastRet = -1;
        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;
        public boolean hasNext() {
            return cursor != size();
        }
        public E next() {
            checkForComodification();
            try {
                int i = cursor;
                E next = get(i);
                lastRet = i;
                cursor = i + 1;
                return next;
            } catch (IndexOutOfBoundsException e) {
                checkForComodification();
                throw new NoSuchElementException();
            }
        }
        public void remove() {
            if (lastRet < 0)
                throw new IllegalStateException();
            checkForComodification();
            try {
                AbstractList.this.remove(lastRet);
                if (lastRet < cursor)
                    cursor--;
                lastRet = -1;
                expectedModCount = modCount;
            } catch (IndexOutOfBoundsException e) {
                throw new ConcurrentModificationException();
            }
        }
        final void checkForComodification() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
        }
    }java

抽象工厂模式

1、工厂方法中的工厂只生产同一产品等级的生产
2、抽象工厂的生产同一产品族中的产品

建造者模式

定义：将一个复杂对象的建造和它的表示分离，使得同样的建造过程有不同的表示

      用户只需指定需要建造的类型就可以得到它们，建造过程及细节不需要知道

适用场景一个类有很多属性，把复杂的对象的创建和使用分离
复杂对象相当于一辆有待建造的汽车，而对象的属性相当于汽车的部件，建造产品的过程就相当于组合部件的过程。由于组合部件的过程很复杂，因此，这些部件的组合过程往往被“外部化”到一个称作建造者的对象里，建造者返还给客户端的是一个已经建造完毕的完整产品对象，而用户无须关心该对象所包含的属性以及它们的组装方式，这就是建造者模式的模式动机。

package com.lilei.design.pattern.creational.builder.v2;
public class Course {
    private String courseName;
    private String ppt;
    private String courseVideo;
    private String article;
    private String QA;
    public Course(CourseBuilder courseBuilder) {
        this.courseName = courseBuilder.courseName;
        this.ppt = courseBuilder.ppt;
        this.courseVideo = courseBuilder.courseVideo;
        this.article = courseBuilder.article;
        this.QA = courseBuilder.QA;
    }
    @Override
    public String toString() {
        return "Course{" +
                "courseName='" + courseName + '\'' +
                ", ppt='" + ppt + '\'' +
                ", courseVideo='" + courseVideo + '\'' +
                ", article='" + article + '\'' +
                ", QA='" + QA + '\'' +
                '}';
    }
    public static class CourseBuilder{
        private String courseName;
        private String ppt;
        private String courseVideo;
        private String article;
        private String QA;
        public CourseBuilder buildCourseName(String courseName) {
            this.courseName = courseName;
            return this;
        }
        public CourseBuilder buildPpt(String ppt) {
            this.ppt = ppt;
            return this;
        }
        public CourseBuilder buildCourseVideo(String courseVideo) {
            this.courseVideo = courseVideo;
            return this;
        }
        public CourseBuilder buildArticle(String article) {
            this.article = article;
            return this;
        }
        public CourseBuilder buildQA(String QA) {
            this.QA = QA;
            return this;
        }
        public Course build(){
            return new Course(this);
        }
    }
}

单例模式

有线程安全问题

package com.lilei.design.pattern.creational.singleinstance;
public class LazySingleton {
    private static LazySingleton lazySingleton = null;
    private LazySingleton() {
    }
    public static LazySingleton getInstance(){
        if (lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

补充一个多线程调试的方法

1、右击断点，选择thread

2、在frame下选择thread

运行线程单击run

单例模式双重检查锁

package com.lilei.design.pattern.creational.singleinstance;
/**
 * 双重检查锁 在性能和安全之间平衡
 */
class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null;
    private LazyDoubleCheckSingleton() {
    }
    public  static LazyDoubleCheckSingleton getInstance(){
        if (lazyDoubleCheckSingleton == null){
            //只锁住一小部分代码
            synchronized (LazyDoubleCheckSingleton.class){
                if (lazyDoubleCheckSingleton ==null)
                lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton();
            }
        }
        return lazyDoubleCheckSingleton;
    }
}

2.对象创建的排序问题

lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton(); 对象创建还没有完全完成

但lazyDoubleCheckSingleton已经指向了内存空间，此时访问对象会造成隐患

原型模式

指原型实例指定创建对象的种类，通过拷贝这些原型创建新的对象

适用场景

1、类初始化消耗过多资源

2、new 对象需要非常繁琐

3、构造函数非常复杂

4、循环中产生大量对象

即使用克隆来创建复杂对象

package com.lilei.design.pattern.prototype;
public class Mail implements Cloneable {
    private String username;
    private String address;
    private String content;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Mail{" +
                "username='" + username + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

深拷贝和浅拷贝

package com.lilei.design.pattern.prototype.deepcopy;
import java.util.Date;
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Pig pig = new Pig("佩奇", new Date(0));
        Pig pig1 = (Pig) pig.clone();
        /*   pig.setBirthday(new Date(1112121));
        * Pig{name='佩奇', birthday=Thu Jan 01 08:18:32 CST 1970}com.lilei.design.pattern.prototype.deepcopy.Pig@511baa65
          Pig{name='佩奇', birthday=Thu Jan 01 08:00:00 CST 1970}com.lilei.design.pattern.prototype.deepcopy.Pig@28feb3fa
        * 这种写法pig中的birthday会赋值为一个新的引用，指向新的内存
         *  */
        //这种修改pig.birthday引用指向的内存中的东西 但两个对象还是拥有同一个引用 所以都会被修改
        //解决办法就是 将 pig.birthday 再克隆一下
        pig.getBirthday().setTime(111111111);
        System.out.println(pig);
        System.out.println(pig1);
    }
}

package com.lilei.design.pattern.prototype.deepcopy;
import java.util.Date;
public class Pig implements Cloneable {
    String name;
    Date   birthday;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Pig pig =(Pig)super.clone();
        //深克隆
        pig.birthday = (Date)pig.birthday.clone();
        return pig;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public Pig(String name, Date birthday) {
        this.name = name;
        this.birthday = birthday;
    }
    @Override
    public String toString() {
        return "Pig{" +
                "name='" + name + '\'' +
                ", birthday=" + birthday +
                '}'+super.toString();
    }
}

3、结构性模式

适配器模式

意图：将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
主要解决：主要解决在软件系统中，常常要将一些”现存的对象”放到新的环境中，而新环境要求的接口是现对象不能满足的。
何时使用： 1、系统需要使用现有的类，而此类的接口不符合系统的需要。 2、想要建立一个可以重复使用的类，用于与一些彼此之间没有太大关联的一些类，包括一些可能在将来引进的类一起工作，这些源类不一定有一致的接口。 3、通过接口转换，将一个类插入另一个类系中。（比如老虎和飞禽，现在多了一个飞虎，在不增加实体的需求下，增加一个适配器，在里面包容一个虎对象，实现飞的接口。）

实现

我们有一个 MediaPlayer 接口和一个实现了 MediaPlayer 接口的实体类 AudioPlayer。默认情况下，AudioPlayer 可以播放 mp3 格式的音频文件。
我们还有另一个接口 AdvancedMediaPlayer 和实现了 AdvancedMediaPlayer 接口的实体类。该类可以播放 vlc 和 mp4 格式的文件。
我们想要让 AudioPlayer 播放其他格式的音频文件。为了实现这个功能，我们需要创建一个实现了 MediaPlayer 接口的适配器类 MediaAdapter，并使用 AdvancedMediaPlayer 对象来播放所需的格式。
AudioPlayer 使用适配器类 MediaAdapter 传递所需的音频类型，不需要知道能播放所需格式音频的实际类。AdapterPatternDemo 类使用 AudioPlayer 类来播放各种格式。

外观模式

定义：提供一个统一接口用来访问子系统中的一群接口，外观模式定义一个高层接口，让子系统更易用

使用场景：

1.子系统复杂，增加外观模式提供简单调用接口，

2.构建多层系统结构，利用外观模式作为每层的入口，简化层间调用

IGiftExchangeSerice作为访问三个子系统的一个高层接口，提供给Test应用层

package com.lilei.design.pattern.structural.facade;
/**
实现类调用子系统
*/
public class IGiftExchangeServiceImpl implements IGiftExchangeService {
    private QualifyService qualifyService = new QualifyService();
    private ShippingService shippingService = new ShippingService();
    private PointsPaymentService pointsPaymentService = new PointsPaymentService();
    @Override
    public void giftExchange(PointGift pointGift) {
        if (qualifyService.isAvailable(pointGift)) {
            if (pointsPaymentService.pay(pointGift)) {
                String number = shippingService.shipGift(pointGift);
                System.out.println("兑换成功，物流号为：" + number);
            }
        }
    }
}

装饰者模式：

定义在不改变类的基础上，将功能附加到对象上

适用场景拓展一个类的功能或给类添加附加职责

package com.lilei.design.pattern.decorator.v2;
public class AbstractDecorator extends ABatterCake {
    //装饰者模式的核心，将要装饰的对象传递到装饰类中 复写其方法
    private ABatterCake aBatterCake;
    public AbstractDecorator(ABatterCake aBatterCake) {
        this.aBatterCake = aBatterCake;
    }
    @Override
    protected String getDesc() {
        return aBatterCake.getDesc();
    }
    @Override
    protected int getPrice() {
        return aBatterCake.getPrice();
    }
}

package com.lilei.design.pattern.decorator.v2;
public class EggDecorator extends AbstractDecorator{
    public EggDecorator(ABatterCake aBatterCake) {
        super(aBatterCake);
    }
    @Override
    protected String getDesc() {
        return super.getDesc()+"加一个鸡蛋";
    }
    @Override
    protected int getPrice() {
        return super.getPrice()+1;
    }
}

package com.lilei.design.pattern.decorator.v2;
public class SausageDecorator  extends AbstractDecorator{
    public SausageDecorator(ABatterCake aBatterCake) {
        super(aBatterCake);
    }
    @Override
    protected String getDesc() {
        return super.getDesc()+"加一根火腿肠";
    }
    @Override
    protected int getPrice() {
        return super.getPrice()+2;
    }
}

package com.lilei.design.pattern.decorator.v2;
public class Test {
    public static void main(String[] args){
        ABatterCake aBatterCake = new BatterCakeImpl();
        //每次套娃，入参是新的对象
        aBatterCake  = new EggDecorator(aBatterCake);
        aBatterCake  = new EggDecorator(aBatterCake);
        aBatterCake  = new SausageDecorator(aBatterCake);
        System.out.println(aBatterCake.getDesc()+"price "+aBatterCake.getPrice());
    }
}

适配器模式

定义：将一个类的接口转换成客户期望的另一个接口

享元模式

定义：提供了减少对象数量从而改善应用所需的对象结构的方式

运用共享技术有效地支持大细粒度的对象

应用于系统底层，系统有大量相识对象，需要缓冲池的场景

4、行为形模式

策略模式(&&)

定义：定义了算法家族，分别封装起来，让他们之间可以相互转换，模式让算法的变化不会影响到使用算法的用户

     我的理解：将具体的，细粒度小的业务逻辑抽象为策略

适用场景：有大量的if else

              一个系统要动态的在几种算法（策略）装选择一种

package com.lilei.design.pattern.strategy;
public interface PromotionStrategy {
    void doPromotion();
}

package com.lilei.design.pattern.strategy;
public class ManjianStrategy implements PromotionStrategy {
    @Override
    public void doPromotion() {
        System.out.println("执行满减策略");
    }
}

package com.lilei.design.pattern.strategy;
public class PromotionActivity {
    private PromotionStrategy promotionStrategy;
    public PromotionActivity(PromotionStrategy promotionStrategy) {
        this.promotionStrategy = promotionStrategy;
    }
    public void execPromotionStrategy(){
        promotionStrategy.doPromotion();
    }
}

package com.lilei.design.pattern.strategy;
public class Test {
    public static void main(String[] args){
        PromotionActivity promotionActivity = new PromotionActivity(new ManjianStrategy());
        promotionActivity.execPromotionStrategy();
    }
}

结合工厂模式

package com.lilei.design.pattern.strategy;
import java.util.HashMap;
import java.util.Map;
public class PromotionFactory {
    private  static Map<String,PromotionStrategy> PROMOTION_MAP = new HashMap<>();
    static {
        PROMOTION_MAP.put(PromotionKey.FANXIAN,new FanXIanStrategy());
        PROMOTION_MAP.put(PromotionKey.MANJIAN,new ManjianStrategy());
    }
    private PromotionFactory(){}
    private static final PromotionStrategy NO_PROMOTION = new EmptyStrategy();
    public  static PromotionStrategy getPromotionStrategy(String promotionKey){
        PromotionStrategy promotionStrategy = PROMOTION_MAP.get(promotionKey);
        return promotionStrategy==null ? NO_PROMOTION : promotionStrategy;
    }
    private interface PromotionKey{
        String FANXIAN = "FANXIAN";
        String MANJIAN = "MANJIAN";
    }
}

PromotionActivity promotionActivity = new PromotionActivity(PromotionFactory.getPromotionStrategy("FANXIAN"));
promotionActivity.execPromotionStrategy();

由工厂动态的选择

观察者模式

定义：定义了对象之间一对多的依赖，让多个观察者同时监听某个主题对象，当主题对象发生改变，所有的观察者都会受到通知并更新

责任链模式(&&)

定义：为请求创建接收此次请求的链

使用：一次请求要多个对象中的一个或几个协作完成

备忘录模式

模板方法模式(&&)

定义：定义了一个算法骨架，并允许子类为一个或多个步骤提供实现

一次性实现一个算法不可变的部分，将可变的部分提供给子类实现

package com.lilei.design.pattern.behavoral.templatemthod;
/**
 * 定义算法（业务逻辑）的骨干
 */
public abstract class ACourse {
    protected final void makeCourse(){
        makePPT();
        makeVideo();
        if (needWriteArticle())
           makeArticle();
        packageCourse();
    }
    final void makePPT(){
        System.out.println("制作PPT");
    }
    final void makeVideo(){
        System.out.println("录制视频");
    }
    void makeArticle(){
        System.out.println("编写笔记");
    }
    /**
    钩子方法
    */
    protected boolean needWriteArticle(){
        return false;
    }
    /**
     * 开放给子类
     */
    abstract void packageCourse();
}

package com.lilei.design.pattern.behavoral.templatemthod;
public class DesignPatternCourse extends ACourse {
    @Override
    void packageCourse() {
        System.out.println("提供java源代码");
    }
    @Override
    protected boolean needWriteArticle() {
        return true;
    }
}

package com.lilei.design.pattern.behavoral.templatemthod;
public class Test {
    public static void main(String[] args){
        System.out.println("制作java课程------start-----");
        ACourse aCourse = new DesignPatternCourse();
        aCourse.makeCourse();
        System.out.println("制作java课程------end-----");
    }
}

迭代器模式

定义：顺序访问一个集合对象的各个方法，且不暴露该对象的内部表示，为不同的集合结构提供一个统一的接口

中介者模式

命令模式

访问者模式

解释器模式

状态模式(&&)

定义：允许一个对象在其内部状态改变时，改变它的行为

适用场景：一个对象存在多个状态（不同状态行为不同），且状态可以相互转换

例子：当一个订单在处于创建未付款的状态下可以付款，但订单处于关闭的状态下是不可付款的。

package com.lilei.design.pattern.behavoral.state;
/**
 * 上下文环境对象
 */
public class CourseVideoContext {
    //状态的引用，决定了当前状态
    private CourseVideoState courseVideoState;
    //四种状态实例
    public final static PlayState PALY_STATE = new PlayState();
    public final static SpeedState SPEED_STATE = new SpeedState();
    public final static PauseState PAUSE_STATE = new PauseState();
    public final static StopState STOP_STATE = new StopState();
    public CourseVideoState getCourseVideoState() {
        return courseVideoState;
    }
    public void setCourseVideoState(CourseVideoState courseVideoState) {
        this.courseVideoState = courseVideoState;
        //维护CourseVideoState类中CourseVideoContext的引用 ，用于CourseVideoState实现类使用CourseVideoContext切换状态
        this.courseVideoState.setCourseVideoContext(this);
    }
    //定义了状态切换的方法
    public void play(){
        this.courseVideoState.play();
    }
    public void speed(){
        this.courseVideoState.speed();
    }
    public void pause(){
        this.courseVideoState.pause();
    }
    public void stop(){
        this.courseVideoState.stop();
    }
}

package com.lilei.design.pattern.behavoral.state;
public abstract class CourseVideoState {
    //上下文环境的引用
    protected CourseVideoContext courseVideoContext;
    public void setCourseVideoContext(CourseVideoContext courseVideoContext) {
        this.courseVideoContext = courseVideoContext;
    }
    abstract void play();
    abstract void speed();
    abstract void pause();
    abstract void stop();
}

package com.lilei.design.pattern.behavoral.state;
public class PauseState extends CourseVideoState {
    @Override
    void play() {
        this.courseVideoContext.setCourseVideoState(CourseVideoContext.PALY_STATE);
    }
    @Override
    void speed() {
        this.courseVideoContext.setCourseVideoState(CourseVideoContext.SPEED_STATE);
    }
    @Override
    void pause() {
        System.out.println("视频处于快进状态！");
    }
    @Override
    void stop() {
        this.courseVideoContext.setCourseVideoState(CourseVideoContext.STOP_STATE);
    }
}

package com.lilei.design.pattern.behavoral.state;
public class Test {
    public static void main(String[] args){
        CourseVideoContext courseVideoContext = new CourseVideoContext();
        courseVideoContext.setCourseVideoState(new PlayState());
        System.out.println("当前状态："+courseVideoContext.getCourseVideoState().getClass().getSimpleName());
        courseVideoContext.pause();
        System.out.println("当前状态："+courseVideoContext.getCourseVideoState().getClass().getSimpleName());
        courseVideoContext.speed();
        System.out.println("当前状态："+courseVideoContext.getCourseVideoState().getClass().getSimpleName());
        courseVideoContext.stop();
        System.out.println("当前状态："+courseVideoContext.getCourseVideoState().getClass().getSimpleName());
        courseVideoContext.speed();
    }
}

当前状态：PlayState
当前状态：PauseState
当前状态：SpeedState
当前状态：StopState
ERROR,停止状态不能快进

设计模式

设计模式

接口

1、设计原则

1.1 开闭原则

定义

栗子一枚：

1.2 依赖倒置原则

定义

1.3单一职责原则

定义

1.4接口隔离原则

定义：

1.5最少知道原则

2、创建模式

工厂模式

1.简单工厂

2.工厂方法

抽象工厂模式

建造者模式

单例模式

单例模式 双重检查锁

原型模式

深拷贝和浅拷贝

3、结构性模式

适配器模式

实现

外观模式

装饰者模式：

适配器模式

享元模式

4、行为形模式

策略模式(&&)

观察者模式

责任链模式(&&)

备忘录模式

模板方法模式(&&)

迭代器模式

中介者模式

命令模式

访问者模式

解释器模式

状态模式(&&)

单例模式双重检查锁