Minio

单例模式

饿汉模式

public class SingleClass1 {
    private SingleClass1(){}
    
    private static final SingleClass1 singleClass1 = new SingleClass1();
    
    public static SingleClass1 getInstance() {
        return singleClass1;
    }
}

懒汉模式

//线程不安全
public class SingleClass1 {
    private SingleClass1(){}

    private static SingleClass1 singleClass1;

    public static SingleClass1 getInstance() {
        if(singleClass1==null)
        {singleClass1 = new SingleClass1();}
        return SingleClass1.singleClass1;
    }
}

内部类方式懒加载

public class SingleClass1 {

    private SingleClass1() {
    }
     private static class InnerClass{
       private  static final SingleClass1 singleClass1 = new SingleClass1();
    }

    public static SingleClass1 getInstance() {

        return InnerClass.singleClass1;
    }
}

枚举方式懒加载

public class SingleClass1 {
    private SingleClass1() {
    }
    private enum InnerClass {
        /**
         *
         */
        INSTANCE;
        private final SingleClass1 singleClass1;
        /**枚举类型的构造器只会被实例化一次*/
        InnerClass() {
            singleClass1 = new SingleClass1();
        }
        SingleClass1 getInstance() {
            return singleClass1;
        }
    }
    public static SingleClass1 getInstance() {
        return InnerClass.INSTANCE.getInstance();
    }
}

双重校验锁懒加载

//effectivejava中提供的方式
public class SingleClass1 {
    private SingleClass1() {
    }
    //volatile 可以保证SingleClass1在初始化完成后再被加载
    private static volatile SingleClass1 singleClass1;
    
    public static SingleClass1 getInstance() {
        if (singleClass1 == null) {
            synchronized (SingleClass1.class) {
                if (singleClass1 == null) {
                    singleClass1 = new SingleClass1();
                }
            }
        }
        return SingleClass1.singleClass1;
    }
}

观察者模式

主体

public class Subject {
	ArrayList<Observer> list = new ArrayList<Observer>();

	public Subject() {
	}

	public Subject register(Observer observer) {
		list.add(observer);
		return this;
	}

	public Subject remove(Observer observer) {
		list.remove(observer);
		return this;
	}

	private void notifyToObserver() {
		if (!list.isEmpty()) {
			for (Observer o : list) {
				o.update();
			}
		}
	}

	public void working()
	{
		Optional.of("准备通知所有看着我的人 我获奖了").ifPresent(System.out::println);
		notifyToObserver();
	}

}

观察者

public interface Observer {
	void update();
}
class A implements Observer {
	@Override
	public void update() {
		Optional.of("A: 他能获奖？").ifPresent(System.out::println);
	}
	void  reg(Subject subject)
	{
		subject.register(this);
	}
}
class B implements Observer {
	@Override
	public void update() {
		Optional.of("B:我也想获奖").ifPresent(System.out::println);
	}
	void  reg(Subject subject)
	{
		subject.register(this);
	}
}

test

public class Test {
	public static void main(String[] args) {
		Subject subject = new Subject();
		new A().reg(subject);
		new B().reg(subject);
		subject.working();
	}
}

我们可以看到，我们的观察者A和B观察到主体获奖之后也发表了自己的感慨！。

监听者模式

个人认为 监听者和观察者最大的区别就是需要回调事件的方法 而观察者则调用观察者的方法。

首先我们提供一个监听器的集合来存储监听器，并提供监听器的注册方法，在要执行的具体方法时事件源注册给事件 再将事件注册给各个监听器，这时 ，监听器就可以触发所需的事件。

public class EventSource {
	//注册事件监听
	ArrayList<MyEventListenner> eventlist = new ArrayList<>();

	//报名 项目是否报名
	ArrayList<String> enlist = new ArrayList<>();


	EventSource registry(MyEventListenner eventListener) {
		eventlist.add(eventListener);
		return this;
	}


	//跑步项目
	void run() {
		//事件委托给监听器
		if (!eventlist.isEmpty()) {
			MyEvent event = new MyEvent(this);
			for (MyEventListenner e : eventlist)
				e.getevnsource(event);
		}
		Optional.of("我终于可以参加跑步比赛了").ifPresent(System.out::println);
	}

	//报名
	void enlist(String run) {
		enlist.add(run);
	}

	ArrayList<String> getenlist() {
		return enlist;
	}
}
public class MyEvent extends EventObject {

	public MyEvent(Object source) {
		super(source);
	}
	@Override
	public Object getSource() {
		return super.getSource();
	}

	public void isenlist()
	{
		//那个这个事件源判断他报没报名
		  if(!((EventSource)getSource()).getenlist().contains("run"))
			  Optional.of("兄弟你没报名啊").ifPresent(System.out::println);
	}
	public void isenlist1()
	{
		if(!((EventSource)getSource()).getenlist().contains("run"))
			Optional.of("兄弟赶紧报名啊").ifPresent(System.out::println);
	}
}
public abstract class MyEventListenner implements EventListener {
	public abstract void getevnsource(EventObject eventObject);
}
class MyEventListenner1 extends MyEventListenner {
	@Override
	public void getevnsource(EventObject eventObject) {
		((MyEvent)eventObject).isenlist();
	}
}
class MyEventListenner2 extends MyEventListenner {
	@Override
	public void getevnsource(EventObject eventObject) {
		((MyEvent)eventObject).isenlist1();
	}
}
public class Test1 {
	public static void main(String[] args) {
		EventSource eventSource = new EventSource();
		eventSource.registry(new MyEventListenner1()).registry(new MyEventListenner2()).run();
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		eventSource.enlist("run");
		eventSource.run();
	}
}