1.单例模式
懒汉式(线程不安全)
private Singleton(){
}
private static Singleton singleton=null;
public static Singleton getInstance(){
if(singleton==null){
singleton=new Singleton();
}
return singleton;
}
}
private Singleton(){
}
private static final Singleton singleton=new Singleton();
public static Singleton getInstance(){
return singleton;
}
}
}
解决懒汉式线程不安全的问题,在getInstance方法上加synchronized关键字
即 public static synchronized Singleton getInstance()
但是直接在方法上加synchronized关键字这样的效率低下,可以采取以下方式:
public Class Singleton{
private Singleton singleton=null;
private Singleton(){}
public static Singleton getInstance(){
if(singleton==null){ //第一次检查
synchronized(Singleton.class){
if(singleton==null){ //第二次检查
singleton=new Singleton();
}
}
}
return singleton;
}
}
2.观察者模式
观察者模式定义了一种一对多的依赖关系,让多个观察者对象同时观察一个主题对象。这个主题对象在发生变化时,会通知所有的观察者对象,使它们能够更新自己。
UML图
一般Subject和Observer定义为抽象类或接口,图中四个角色抽象主题、具体主题、抽象观察者和具体观察者
代码:
public abstract Subject{
private List
observers=new List<>();
public void attach(Observer observer){
observers.add(observer);
}
public void detach(Observer observer){
observers.remove(observer);
}
public void notify(){
for(Observer o:observers){
o.update();
}
}
}
public class ConcreteSubject{
private String state;
public String getState(){
return state;
}
public void change(String newState){
this.state=newSate;
this.notify();
}
}
public interface Observer{
public void update();
}
public class ConcreteObserver implements Observer{
priavte String observerState;
public ConcreteObserver(String observerState){
this.observerState=observerState;
}
public void update(){ //观察者完成自己的更新
System.out.println("状态为"+observerState+"的观察者更新自己");
}
}