设计模式

观察者模式

观察者模式是对象的行为模式，定义了一种一对多的依赖关系，让多个观察者同时监听同一个主题对象。这个主题对象发生状态变化时，会通知所有观察者对象，让他们可以即使更新自己。

一个软件系统中，某一个对象发生状态变化时，某些其他的对象发生相应改变。为了使系统能够易于复用，应该选择低耦合度的设计方案，维持对象间协调一致，保证协作性。观察者模式满足这些需求。

典型：Servlet的Listener的监听器。

观察者模式涉及的角色：

1.抽象主题角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集中，每个主题可以有多个观察者对象。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做被观察者对象。
2.具体主题角色：将有关状态存入具体观察者对象；在具体主题状态改变时，给所有登记过的观察者发送通知。
3.抽象观察者角色：为所有的具体观察者定义一个接口，在得到主题通知时更新自己。
4.具体观察者角色：实现更新接口方法。

代码样例

抽象主题类：

public abstract class Subject {
    /**
     * 用来保存注册的观察者对象
     */
    private    List list = new ArrayList();
    /**
     * 注册观察者对象
     * @param observer    观察者对象
     */
    public void attach(Observer observer){
        
        list.add(observer);
        System.out.println("Attached an observer");
    }
    /**
     * 删除观察者对象
     * @param observer    观察者对象
     */
    public void detach(Observer observer){
        
        list.remove(observer);
    }
    /**
     * 通知所有注册的观察者对象
     */
    public void nodifyObservers(String newState){
        
        for(Observer observer : list){
            observer.update(newState);
        }
    }
}

具体主题:

public class ConcreteSubject extends Subject{
    
    private String state;
    
    public String getState() {
        return state;
    }

    public void change(String newState){
        state = newState;
        System.out.println("主题状态为：" + state);
        //状态发生改变，通知各个观察者
        this.nodifyObservers(state);
    }
}

抽象观察者:

public interface Observer {
    /**
     * 更新接口
     * @param state    更新的状态
     */
    public void update(String state);
}

具体观察者:

public class ConcreteObserver implements Observer {
    //观察者的状态
    private String observerState;
    
    @Override
    public void update(String state) {
        /**
         * 更新观察者的状态，使其与目标的状态保持一致
         */
        observerState = state;
        System.out.println("状态为："+observerState);
    }

}

调用:

public class Client {

    public static void main(String[] args) {
        //创建主题对象
        ConcreteSubject subject = new ConcreteSubject();
        //创建观察者对象
        Observer observer = new ConcreteObserver();
        //将观察者对象登记到主题对象上
        subject.attach(observer);
        //改变主题对象的状态
        subject.change("new state");
    }

}

单例模式

单例模式--概念

单例模式常见的写法有：懒汉式，饿汉式，登记式。
单例模式的特点有：
1.单例类只能有1个实例
2.单例类必须自己创建自己的唯一实例
3.单例类必须给其他对象提供这个实例

选择单例模式可以避免不一致的状态。

懒汉式单例

//懒汉式单例类.在第一次调用的时候实例化自己   
public class Singleton {  
    private Singleton() {}  
    private static Singleton single=null;  
    //静态工厂方法   
    public static Singleton getInstance() {  
         if (single == null) {    
             single = new Singleton();  
         }    
        return single;  
    }  
}  

在第一次调用的时候实例化自己，构造函数是私有的，防止被其他类实例化。它是线程不安全的。

饿汉式单例

public class Singleton1 {  
    private Singleton1() {}  
    private static final Singleton1 single = new Singleton1();  
    //静态方法   
    public static Singleton1 getInstance() {  
        return single;  
    }  
}  

饿汉式在类被创建好后就完成自身实例化，是线程安全的。

单例模式可以保证只有单例类自身1个实例，并提供全局访问点。
单例模式可以作用于仓库类，控制线程之间的并发访问。
数据库连接池就是一种单例模式。

工厂模式

作用：创建不同的对象。好处是让把创建对象的过程从业务中分离出来。
简单工厂： 根据传入参数，判断获得的对象。缺点是一个新的对象，就要对应一个工厂，代码量多。

桥梁模式

作用：让抽象和实现解耦，使两者可以独立的变化。
角色：
1.接口 定义方法
2.接口实现类，实现业务逻辑。
3.抽象类，作为桥梁，连接到接口。
4.角色类，继承抽象类，实现业务逻辑。

适配器模式

将一个类的接口转换为客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以在一起工作。

包含角色：
1.目标接口(target)：客户目标所需要的接口。也可以是抽象类，或者普通类。
2.需要适配的类(Adaptee)：需要适配的类 。
3.适配器(Adapter)：通过包装一个需要适配的对象，把原接口转换成目标接口。