设计模式（二）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

结构型模式

适配器模式

类似与转换接头的作用

//适配类
public class Adaptee {
    public void request(){
        System.out.println("适配成功");
    }
}
===
//接口转换器的抽象实现
public interface NetToUsb {
    //处理接口
    public void handleRequest();
}
===
//继承（类适配器）
//真正的适配器，需要连接usb和电脑
/*public class Adapter extends Adaptee implements NetToUsb{
    @Override
    public void handleRequest() {
        super.request();
    }
}*/
//组合（对象适配器，常用）
public class Adapter implements NetToUsb{
    private  Adaptee adaptee;

    public void setAdaptee(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void handleRequest() {
        adaptee.request();
    }
}
===
//客户端，想上网，插不上网线
public class computer {
    public void net(NetToUsb adapter)
    {
        //上网的具体实现,需要一个转接头
        adapter.handleRequest();
    }
}

桥接模式

public interface Brand {
    public void info();
}
====
public class Brand1 implements Brand {
    @Override
    public void info() {
        System.out.println(1);
    }
}
===
public class Brand2 implements Brand {
    @Override
    public void info() {
        System.out.println(2);
    }
}
===
//抽象电脑
public abstract class Computer {

    //组合
    protected Brand brand;
    public Computer(Brand brand) {
        this.brand = brand;
    }
    public void info()
    {
        brand.info();
    }

}
===
class Desktop extends Computer{

    public Desktop(Brand brand) {
        super(brand);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("台式机");
    }
}
===
class Latop extends Computer {
    public Latop(Brand brand) {
        super(brand);
    }

    @Override
    public void info() {
        super.info();
        System.out.println("笔记本");
    }
}

初始

桥接

装饰者模式

在不改变现有对象结构的情况下，动态的给对象加一些职责

garnish那一块就是装饰，如果需要在添加配料只需要继承garnish,并像egg一样实现即可

//抽象构建角色
public abstract class FastFood {
    private float price;//价格
    private String desc;//描述
    public abstract float cost();

}
===
//具体的实现类
public class FireNoodles extends FastFood{
    public FireNoodles() {
        super(8, "炒面");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}
===
//具体构建角色
public class FireRice extends FastFood{
    public FireRice() {
        super(10, "炒饭");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}
===
//装饰者类（抽象装饰者角色）
@Data
public abstract class Garnish extends FastFood {
    //声明快餐类变量
    private FastFood fastFood;

    public Garnish(float price, String desc,FastFood fastFood) {
        super(price, desc);
        this.fastFood = fastFood;
    }
}
===
//具体的装饰者
public class Bacon extends Garnish {
    public Bacon(float price, String desc, FastFood fastFood) {
        super(4, "培根", fastFood);
    }

    @Override
    public float cost() {
        return getPrice()+getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }
}
===
//具体的装饰者
public class Egg extends Garnish {
    public Egg(float price, String desc, FastFood fastFood) {
        super(3, "鸡蛋", fastFood);
    }

    @Override
    public float cost() {
        return getPrice()+getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc()+getFastFood().getDesc();
    }
}

使用场景

继承不能使用的情况下（1，类定义不可继承（final）2，存在大量扩展，为支持每一种组合将会产生大量子类）
在不影响其他的对象的情况下，动态的添加职责
动态的添加和动态的撤销

外观模式

为多个复杂的子系统提供一个统一的接口

降低了子系统和客户端的耦合度，会客户屏蔽了子系统组件，使得使用子系统更加容易，但是不符合开闭原则。

组合模式

树型结构

享元模式

系统大量类似的对象，可以节省大量内存和cpu资源
两种状态：内部状态：共享部分，外部状态：不可共享部分

代理模式

类似于中介
抽象主题类：声明真实主题和代理对象实现的业务方法
真实主题类：实现抽象主题中的业务方法
代理类：提供了与真实主题相同的接口，内部含有真实主题的引用，可以访问、控制、扩展主题

静态代理

动态代理

jdk动态代理

java提供的Proxy类中的newProxyInstance (类加载器，代理类实现的接口，代理对象的调用处理程序)

cglib动态代理

需要引入cglib的包

//创建对象，类似与jdk中的Proxy
Enhancer e = new Enhancer();
//获取父类字节码 xxx.class
e.setSuperclass()
// 设置回调函数
e.setCallback(this);
//创建代理对象
return enhancer.create();

行为型模式

模板方法模式

模板方法：定义了算法的骨架
基本方法：实现算法各个步骤的方法（分为三种）
1.抽象方法:抽象类声明
2.具体方法:由一个抽象类或具体类声明并实现，其子类可以覆盖和继承
3.钩子方法:抽象类中已经实现（判断的逻辑方法和需要子类重写），一般是用于判断的逻辑方法
具体子类：实现抽象类所定义的抽象方法和钩子方法

策略模式

类似与我们出行的方式很多，可以步行，开车等

策略类之间可以自由切换，易于扩展，但是客户端需要知道所有的策略类，会产生很多的策略类（可以使用享元模式减少策略数量）

命令模式

将一个请求封装成对象，使发出请求的责任和执行请求的责任分割开来。
抽象命令类:定义命令的接口，声明执行的方法
具体命令类：实现命令的接口
实现者（接收者）：执行命令的对象
调用者（请求者）: 要求命令对象执行请求

责任链模式

当有请求时沿着链传递，直到有对象能处理为止
抽象处理者：定义一个处理请求的接口
具体处理者：实现抽象处理者的方法，判断能否处理本次请求，如果不可以就将请求转给后继者，可以就处理
客户端角色：创建处理链，并向链头的具体处理者对象发起请求，它不关心处理细节和请求的传递过程。

状态模式

把复杂的逻辑判断提取到不同的状态类中
环境角色：也叫上下文，定义了用户所需要的接口。
抽象状态角色：用来封装环境对象中的特定状态行为
具体状态角色：实现抽象类所对应的行为

观察者模式

又被叫做发布订阅模式，它定义了一种一对多的关系，让多个观察者对象同时监听某一主题对象，这个主题对象在状态发生变化时，会通知所有的观察者对象，是他们能够改变自己。
subject:抽象主题（抽象被观察者），把所有的观察者对象保存在一个集合中，每个主题都有任意数量的观察者，提供可以删除和添加观察者的接口。
concretesubject：具体主题（具体被观察者）
observer：抽象观察者，定义了一个更新接口，使得在主题发生改变时更新自己
concreteObserve：具体观察者，实现抽象观察者的更新接口

中介者模式