23种设计模式笔记-优快云博客

本文链接：https://blog.youkuaiyun.com/2509_90931430/article/details/146158876

创建型模式，
- 简单工厂模式 simple factory
- 工厂方法模式 factory
- 抽象工厂模式 abstract factory
- 单例模式
- 建造者模式
- 原型模式 prototype
结构型模式
- 适配器模式
  - 扩展类增强类
- 装饰器模式
  - 增强类
- 代理模式
  - 静态代理就是装饰者模式
- 外观模式
  - 也叫门面模式系统种存在特别复杂的业务需要业务自己调用很多接口，此时门面模式整合这些接口对外暴露出一个service
  - facade
  - 类似网关对前端暴露一个域名就够了
  - 已有的资源封装起来只留下一个方法
- 桥接模式
- 组合模式
  - 类引用类都叫组合
- 享元模式
  - 池化技术核心模式
  - 共享数据及状态变更的操作
行为型模式，共十一种
- 策略模式
- 模板方法模式
- 观察者模式
- 迭代模式
- 责任链模式
- 命令模式
- 备忘录模式
  - 就是保存初始数据信息，以便备份
- 状态模式
- 访问者模式
- 中介者模式
- 解释器模式

单例模式


/**
* 懒加载单例模式
*/
public class LazySinglton {

   private static LazySinglton instance;
   private LazySinglton() {

   }
   public static LazySinglton getInstance() {
       if(instance == null) {
           instance = new LazySinglton();
       }
       return instance;
   }
}


/**
* 预加载单例
*/
public class PreSingleton {

   private static PreSingleton instance = new PreSingleton();
   private PreSingleton() {

   }
   public static PreSingleton getInstance() {
       return instance;
   }
}

工厂模式

简单工厂模式

核心就是TransportFactory 方法根据类型获取对象
缺点产品族单一

public abstract class Transport {

    protected  String sing;

    public abstract void run();


    public void say(){
        System.out.println("运输方式的叫声" + sing);
    }


}

public class Car extends Transport{

    public Car(){
        this.sing = "小汽车 喀喀喀";
    }
    @Override
    public void run() {
        System.out.println("陆地上跑的 80迈");
    }
}

public class Lv extends Transport{

    public Lv(){
        this.sing = "小毛驴 儿啊儿啊";
    }
    @Override
    public void run() {
        System.out.println("陆地上四脚跑的 20迈");
    }
}

public class TransportFactory {

    public static Transport createTransport(String type){
        if("car".equals(type)){
            return  new Car();
        }else if("lv".equals(type)){
            return  new Lv();
        }
        return null;
    }
}

模板方法工厂模式

从简单工厂上提升一下产品族把要生产的对象变成抽象的

public abstract class Transport1 {
    protected  String sing;
    public abstract void run();
    public void say(){
        System.out.println("运输方式的叫声" + sing);
    }
}

public class Lv1 extends Transport1 {

    public Lv1(){
        this.sing = "小毛驴 儿啊儿啊";
    }
    @Override
    public void run() {
        System.out.println("陆地上四脚跑的 20迈");
    }
}

public class Car1 extends Transport1 {

    public Car1(){
        this.sing = "小汽车 喀喀喀";
    }
    @Override
    public void run() {
        System.out.println("陆地上跑的 80迈");
    }
}
public abstract  class AbstractTransportFactory {

    public abstract Transport1 createTransport();
}

public class BenZiCarFactory extends AbstractTransportFactory {
    @Override
    public Transport1 createTransport() {
        return new Car1();
    }
}

抽象工厂

针对可扩展品类再次提升一个档次不需要实现的工厂默认实现为null
需要实现的子类自己实现

public abstract class AbstractFactory {
    abstract Transport1  createTransport();
    abstract MakeMoney makeMoney();
}

public abstract  class AbstractTransportFactory extends AbstractFactory{
    @Override
    MakeMoney makeMoney() {
        return null;
    }
}

原型模式

最核心就是clone 不需要单独创建对象
而且改变原型类不会改变对象本身

@Data
public class Animal implements Cloneable {
    private String name;
    private String type;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class DB {


    public Animal select() throws CloneNotSupportedException {
        Animal animal = new Animal();
        animal.setName("狸花猫");
        animal.setType("小猫咪");
        return (Animal)animal.clone();
    }
}

public class DbPrototypeMain {
    public static void main(String[] args) throws CloneNotSupportedException {
        DB db = new DB();
        Animal select = db.select();

        select.setName("猫咪的徒弟");
        select.setType("老虎");
        System.out.println(select);

        Animal select1 = db.select();
        System.out.println(select1);
    }
}

代理模式

JDK代理

只能代理有接口的类


public interface JdkInterface {
    void sayHello();
}

public class JdkImpl implements JdkInterface{
    @Override
    public void sayHello() {
        System.out.println("he ll o wo r l d");
    }
}



import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class JdkProxy implements InvocationHandler {
    private Object target;
    JdkProxy(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(target, args);
    }
}

CGLIB代理

Enhancer 类增强器
可以代理没有接口的普通对象

public class CglibClass {
    void sayHello() {
        System.out.println("cglib hello world");
    }
}

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;
import java.lang.reflect.Method;
public class CglibInvocatonHandler {
    public  static<T> T createProxy(T t){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(t.getClass());
        enhancer.setCallback(new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                return method.invoke(t, args);
            }
        });
        return (T)enhancer.create();
    }
}

public class CglibProxy {
    public static void main(String[] args) {
        CglibClass cglibClass = new CglibClass();
        CglibClass proxy = CglibInvocatonHandler.createProxy(cglibClass);
        System.out.println(proxy.getClass().getSimpleName());
        proxy.sayHello();
    }
}

享元模式

池化技术的核心
对象本身有需要改变的状态，及不可变的因素可用享元模式进行剥离拆分

public interface WebSit {
     void use(User user);
}

public class ConWebsit implements WebSit {
    private String type;
    public ConWebsit(String type) {
        this.type = type;
    }
    @Override
    public void use(User user) {
        System.out.println(user.name + "使用" + type + "网站");
    }
}
public class User {
    String name;
}


public class WebFactory {
    Map<String,WebSit> pool = new HashMap<String,WebSit>();
    public WebSit getWebSit(String type){
        if(pool.get(type) != null){
            return pool.get(type);
        }
        WebSit webSit = new ConWebsit(type);
        pool.put(type,webSit);
        return webSit;
    }
}


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

        WebFactory webFactory = new WebFactory();
        WebSit webSit = webFactory.getWebSit("新闻网");
        User user = new User();
        user.name = "张三";
        webSit.use(user);

        WebSit webSit1 = webFactory.getWebSit("新闻网");
        User user1 = new User();
        user1.name = "里斯";
        webSit.use(user1);

        System.out.println(webSit == webSit1);
    }
}

适配器模式

适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。
这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。
举个真实的例子，播放器最开始只能播放 mp3 格式的音频文件，通过使用一个更高级的音频播放器来播放其他格式的音频。
适配器模式属于结构型模式。
适配者类：MediaPlayer Mp3MediaPlayerImpl 现在想提升这个功能使用 MP4或clv
适配器类 AdvancedAdapter
目标类：AdvancedMediaPlayer Mp4MediaPlayerImpl 和 ClvMediaPlayerImpl 满足MP4和clv


public interface MediaPlayer {
   void play(String audioType, String fileName);
}
public class Mp3MediaPlayerImpl implements MediaPlayer {
    @Override
    public void play(String audioType, String fileName) {
        System.out.println("map3 播放器播放mp3文件");
    }
}


public interface AdvancedMediaPlayer {
    void playVlc(String fileName);
    void playMp4(String fileName);
}

public class ClvMediaPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("vlc 播放器播放vlc文件");
    }
    @Override
    public void playMp4(String fileName) {
    }
}

public class Mp4MediaPlayer implements AdvancedMediaPlayer{
    @Override
    public void playVlc(String fileName) {
    }
    public void playMp4(String fileName) {
        System.out.println("mp4 播放器播放mp4文件");
    }
}


public class AdvancedAdapter implements MediaPlayer {
    private AdvancedMediaPlayer advancedMediaPlayer;
    private Mp3MediaPlayerImpl mp3MediaPlayer;

    @Override
    public void play(String audioType, String fileName) {
        if(audioType.equalsIgnoreCase("vlc")) {
            advancedMediaPlayer = new ClvMediaPlayer();
            advancedMediaPlayer.playVlc(fileName);
        }else if(audioType.equalsIgnoreCase("mp4")) {
            advancedMediaPlayer = new Mp4MediaPlayer();
            advancedMediaPlayer.playMp4(fileName);
        }else {
            mp3MediaPlayer.play(audioType, fileName);
        }
    }
}

责任链模式

next自己是核心这个可以抽象统一类产品组


@Data
@ToString
public class Teacher {

    private String name;

    private Teacher next;
    public Teacher(String name) {
        this.name = name;
    }

    public void handlerRequest(){
        System.out.println(this.name+"处理了");
        if(next!=null){
            next.handlerRequest();
        }
    }
}

public class ChainMain {

    public static void main(String[] args) {
        Teacher teacher1 = new Teacher("张三");
        Teacher teacher2 = new Teacher("李四");
        Teacher teacher3 = new Teacher("王五");

        teacher1.setNext(teacher2);
        teacher2.setNext(teacher3);

        teacher1.handlerRequest();
    }
}

建造者模式

例子写的不太清晰
建造者针对的是都不是必填的字段
优势就是构造对象时候清晰



public abstract class ZaoFangZi {

    int zhuanNum;

    int dijiNum;

    int fangliangNum;

    int baowenNum;

    abstract ZaoFangZi zhuan();

    abstract ZaoFangZi diji();

    abstract ZaoFangZi fangliang();

    abstract ZaoFangZi baowen();

    public int sum(){
        return fangliangNum + baowenNum + dijiNum + zhuanNum;
    }


}


public class BaoGongTou extends ZaoFangZi {

    private static BaoGongTou instance;

    public static BaoGongTou builder() {
        instance = new BaoGongTou();
        return instance;
    }

    public static BaoGongTou build() {
        return instance;
    }


    @Override
    ZaoFangZi zhuan() {
        this.zhuanNum = 100;
        return this;
    }

    @Override
    ZaoFangZi diji() {
        this.dijiNum = 200;
        return this;
    }

    @Override
    ZaoFangZi fangliang() {
        this.fangliangNum = 300;
        return this;
    }

    @Override
    ZaoFangZi baowen() {
        this.baowenNum = 400;
        return this;
    }
}
public class BuilderMain {
    public static void main(String[] args) {
        ZaoFangZi zaoFangZi = BaoGongTou.builder().zhuan().baowen().diji().fangliang();
        System.out.println(zaoFangZi.sum());
    }
}

访问者模式

不太符合开闭原则
角色
- 元素（Element）
- 访问者（Visitor）
- 对象结构（Object Structure）
- 具体元素（Concrete Element）
- 具体访问者（Concrete Visitor）
需求家里有小动物，需要有人投喂
- 元素 animal 小动物抽象类以后家里可能有猫狗鱼鹅
- 具体元素 dog,cat 具体的小动物
- 对象结构 home 家里有人喂食小动物
- 访问者 Person 主人其他人
- 具体访问者 owner someone
雷神讲的小爱同学的例子小爱同学可以简单的回答问题，存储磁盘，需要打个补丁，进行升级
- 元素硬件
- 具体元素 CPU 内存硬盘
- 对象结构有人访问硬件问问题
- 访问者增强器
- 具体的访问者 updatPack
问题
- 如果按照雷神写得是具体工作类那没多一个具体元素就会违背开闭原则
- 如果按照自己写的抽象类访问，就不会知道要为哪个具体类进行增强只会统一增强

public abstract class HardWare {
    String commond ;
    public abstract void work();
    abstract void action (Visitor visitor) ;
}

public class CPU extends HardWare {

    @Override
    public void work() {
        System.out.println("cpu 开始工作");
    }

    @Override
    void action(Visitor visitor) {
        visitor.visitor(this);
    }

public class Disk extends HardWare {

    @Override
    public void work() {
        System.out.println("disk 开始工作");
    }
    @Override
    void action(Visitor visitor) {
        visitor.visitor(this);
    }
}

public class UpdatePkg implements Visitor{


    @Override
    public void visitor(HardWare hardWare) {
        hardWare.work();
        System.out.println("更新包打补丁 我开始联网处理了");
    }
}

public interface Visitor {


    void visitor(HardWare hardWare);
}

观察者模式

非常常见的一种设计模式
主要是维护一对多的关系（也可以相互关联）
例子主播与粉丝

public abstract class ZhuBo {
    String name;
    abstract  void addFans(Fans fans);
    abstract  void notify(String msg);
}
public class LeijiaYin extends ZhuBo {
	//核心点就是这个list 及通知方法
    List<Fans> fansList = new ArrayList<Fans>();
    LeijiaYin(String name) {
        this.name = name;
    }
    @Override
    void addFans(Fans fans) {
        fansList.add(fans);
    }
    @Override
    void notify(String msg) {
        for (Fans fans : fansList) {
            fans.accept(msg);
        }
    }
}
public abstract class Fans {

    abstract void accept(String msg);
}
public class MmFans extends Fans {
    ZhuBo zhuBo;

    MmFans(ZhuBo zhuBo) {
        this.zhuBo = zhuBo;
    }

    @Override
    void accept(String msg) {
        System.out.println("mmFans 接收到主播" + zhuBo.name + "消息 " + msg);
    }
}
public class ObserverMain {

    public static void main(String[] args) {
        ZhuBo zhuBo = new LeijiaYin("雷佳音");
        zhuBo.addFans(new MmFans(zhuBo));
        zhuBo.addFans(new MmFans(zhuBo));
        zhuBo.addFans(new MmFans(zhuBo));
        zhuBo.notify("我要开始跳舞了");
    }
}

中介者模式

模拟飞机起飞的流程跑道只能有一架飞机起飞
中介者模式就是把散乱的交互统一起来逻辑都放在一起统一维护

//塔台
public class Tower {
    private boolean canFly = true;
    public void action(AbstractPlane plane, String action) {
        if (action.equals("fly")) {
            if (canFly) {
                canFly = false;
                System.out.println(plane.getClass().getSimpleName() + " 起飞");
            }else {
                System.out.println(plane.getClass().getSimpleName() + " 飞机太多，不能起飞");
            }
        }
        if (action.equals("flow")) {
            canFly = true;
        }

    }
}


public abstract class AbstractPlane {
    Tower tower;
    AbstracPlane(Tower tower) {
        this.tower = tower;
    }
    abstract void fly();
    abstract  void flow();
}

public class Plane1 extends AbstractPlane {

    Plane1(Tower tower) {
        super(tower);
    }
    @Override
    void fly() {
        System.out.println("plane1 申请起飞");
        tower.action(this,"fly");
    }
    @Override
    void flow() {
        System.out.println("plane1 申请降落");
        tower.action(this,"flow");
    }
}

public class Plane2 extends AbstractPlane {
    Plane2(Tower tower) {
        super(tower);
    }

    @Override
    void fly() {
        System.out.println("plane2 申请起飞");
        tower.action(this,"fly");
    }

    @Override
    void flow() {
        System.out.println("plane2 申请降落");
        tower.action(this,"flow");
    }
}

状态模式

类图和策略模式是一样的但是主打的就是一个状态进行流转
也可以自己控制状态的流转

public abstract class PlayState {
    PlayState nextState;
    public abstract void play();
}

public class PowerState extends PlayState {

    PowerState(PlayState nextState) {
        this.nextState = nextState;
    }
    @Override
    public void play() {
        System.out.println("我充满力量");
        nextState.play();
    }
}

public class VictoryState extends PlayState {

    VictoryState(PlayState nextState) {
        this.nextState = nextState;
    }

    @Override
    public void play() {
        System.out.println("我胜利了");
        nextState.play();
    }
}
public class TiredState extends PlayState {

    TiredState(PlayState nextState) {
        this.nextState = nextState;
    }

    @Override
    public void play() {
        System.out.println("我累了");
    }
}

public class StateMain {
    public static void main(String[] args) {
        PlayState p3 = new TiredState(null);
        PlayState p2 = new VictoryState(p3);
        PlayState p1 = new PowerState(p2);

        p1.play();

    }
}