设计模式学习

单例模式

饿汉式：

package designPatterns;/**
 * Created by fangjiejie on 2020/9/9.
 */

/**
 * @author : liyafang
 * @description :单例模式
 * @date : 2020-09-09 19:30
 */
public class Singleton {
    private static volatile Singleton instance = null;
    private Singleton(){

    }

    /**
     * 双重锁机制
     * https://www.cnblogs.com/qifenghao/p/8986538.html
     * @return
     */
    public static Singleton getInstance(){
        if(instance == null){//使用volatile关键字避免并发情况下线程阻塞
            synchronized(Singleton.class){
                if(instance == null){//判断instance是否已经被创建
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

适配器模式

把一个接口转换成用户希望的另一个接口，把不兼容的兼容起来

package designPatterns;/**
 * Created by fangjiejie on 2020/9/17.
 */

/**
 * @author : liyafang
 * @description : 适配器模式
 * @date : 2020-09-17 10:18
 */
//把风力发电转化为光源发电
public class AdapterDesignPattern {
    public static void main(String[] args) {
        SunSourceApply sunSourceApply = new SunSourceApply();
        WindSourceApply windSource = new WindSourceApply(sunSourceApply);
        windSource.windApply();
    }
}
interface SunSource{
    void sunApply();
}

interface WindSource{
    void windApply();
}

class WindSourceApply implements WindSource{
    SunSource sunSource;
    public WindSourceApply(SunSource sunSource){
        this.sunSource = sunSource;
    }
    public void windApply(){
        System.out.println("call windApply");
        sunSource.sunApply();
    }
}

class SunSourceApply implements SunSource{
    public void sunApply(){
        System.out.println("in sunSource applying");
    }
}

观察者模式

定义对象之间的一对多依赖，当一个对象状态发生改变时，它的所有依赖都会收到通知并自动更新状态。主题是被观察者的对象，而其所有依赖者被称为观察者。如天气通知
主题: 注册、移除、通知所有观察者。维护一张观察者列表。定义接口，实现
观察者：定义接口（被通知的更新方法），实现。构造函数中，将主题传进来，注册上自己

package designPatterns;/**
 * Created by fangjiejie on 2020/9/17.
 */


import java.util.LinkedList;
import java.util.List;

/**
 * @author : liyafang
 * @description : 观察者模式
 * @date : 2020-09-17 09:24
 */
public class ObserverDesignPattern {

    public static void main(String[] args) {
        WeatherSubject weatherSubject = new WeatherSubject();
        BoardDisplay1 boardDisplay1 = new BoardDisplay1(weatherSubject);
        BoardDisplay2 boardDisplay2 = new BoardDisplay2(weatherSubject);
        weatherSubject.setData(0.11,0.12);
        weatherSubject.notifyObservers();
        weatherSubject.setData(0.81,0.82);
        weatherSubject.notifyObservers();
    }

}
interface Subject{
    void register(ObserverDisplay obj);
    void remove(ObserverDisplay obj);
    void notifyObservers();
}
class WeatherSubject implements Subject{
    private List<ObserverDisplay> list = new LinkedList<>();
    private Double num1;
    private Double num2;
    public void setData(Double num1,Double num2){
        this.num1 = num1;
        this.num2 = num2;
    }
    @Override
    public void register(ObserverDisplay object){
        list.add(object);
    }

    @Override
    public void remove(ObserverDisplay object){
        int index = list.indexOf(object);
        if(index >=0 ){
            list.remove(index);
        }
    }

    @Override
    public void notifyObservers(){
        list.stream().forEach(e->e.update(num1,num2));
    }
}

interface ObserverDisplay{
       void update(Double num1,Double num2);
}

class BoardDisplay1 implements ObserverDisplay{
    public BoardDisplay1(Subject subject){
        subject.register(this);
    }
    public void update(Double num1,Double num2){
        System.out.println("BoardDisplay1 update:"+num1 +" "+ num2);
    }
}
class BoardDisplay2 implements ObserverDisplay{
    public BoardDisplay2(Subject subject){
        subject.register(this);
    }
    public void update(Double num1,Double num2){
        System.out.println("BoardDisplay2 update:"+num1 +" "+ num2);
    }
}

代理模式

静态代理
代理类和被代理类实现同一个接口，用户访问的时候先访问代理对象，由代理对象来处理繁杂的事情，这在个过程中会去访问被代理对象。
如果接口改了，代理对象内部的方法也要跟着改。代理对象和目标对象实现同样的接口，代理类会很多，不易维护。
动态代理
拦截直接访问对象，可以给对象进行增强的一项技能；代理对象的生成，是利用JDKAPI， 动态地在内存中构建代理对象
jdk动态代理:其代理对象必须是某个接口的实现，通过在运行期间创建一个接口的实现类来完成对目标对象的代理。
cglib动态代理:针对没有实现接口的类产生代理，实现原理类似于 jdk 动态代理，只是他在运行期间生成的代理对象是针对目标类扩展的子类。