观察者模式

简介

观察者模式定义了一个多对一的监听和监听，当一个对象改变时，其所有的依赖者都会收到通知并自动更新。

注意

对于JDK或者Andorid中都有很多地方实现了观察者模式，比如XXXView.addXXXListenter ， 当然了 XXXView.setOnXXXListener不一定是观察者模式，因为观察者模式是一种一对多的关系，对于setXXXListener是1对1的关系，应该叫回调。其实观察者模式可以简单的理解为发布者订阅者模式。

实现

public interface Observer {
    //注册观察者（订阅者）
    public void registerObserver(ObserverVo observerVo);
    //删除观察者
    public void removeObserver(ObserverVo observerVo);
    //发送观察者消息
    public void nofityObserver(String msg);
}
public class ObserverImp implements Observer{

    private List<ObserverVo> observerList = new ArrayList<ObserverVo>();

    @Override
    public void registerObserver(ObserverVo observerVo) {
        observerList.add(observerVo);
    }

    @Override
    public void removeObserver(ObserverVo observerVo) {
        observerList.remove(observerVo);
    }

    @Override
    public void nofityObserver(String msg) {
        if (observerList != null && observerList.size() > 0){
            for (ObserverVo observerVo : observerList){
                observerVo.update(msg);//执行所有订阅者的更新
            }
        }
    }
}
//观察者实体
public interface ObserverVo {
    public void update(String msg);
}
public class ObserverVoImpl implements ObserverVo {

    //构造函数
    public ObserverVoImpl(Observer observer){
        observer.registerObserver(this);
    }

    @Override
    public void update(String msg) {
        System.out.println("收到的通知为+++"+msg);
    }
}
public class Main {

    public static void main(String[] args) {
        System.out.println("design model excute!");
        Observer observer = new ObserverImp();
        ObserverVo observerVo1 = new ObserverVoImpl(observer);//监听当前订阅者
        observer.nofityObserver(">>>>>>发布消息啦！");
    }
}

工厂模式

简介

一般就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

注意

工厂模式常见的有三种，一种是静态工厂模式，不需要创建工厂对象，使用的比较多，二是通过传入字符串创建不同对象，三是创建多个方法进行不同对象的创建。这里主要是实现静态工厂模式。

public class Factory {
    public static Sender produceSmsSender(){
        return new SMSSender();
    }
    public static Sender produceMailSender(){
        return new MailSender();
    }
}
public interface Sender {
    public void sendMsg(String msg);
}
public class MailSender implements Sender {
    @Override
    public void sendMsg(String msg) {
        System.out.println("Mail send msg is >"+msg);
    }
}
public class SMSSender implements Sender {
    @Override
    public void sendMsg(String msg) {
        System.out.println("SMS >>>>>msg is"+msg);
    }
}

public class Main {
    public static void main(String[] args){
        System.out.println(">>>>>>factory excute");
        Sender mailSender = Factory.produceMailSender();
        Sender smsSender = Factory.produceSmsSender();
        mailSender.sendMsg("mail msg");
        smsSender.sendMsg("sms msg");
    }
}

单例模式

简介

单例模式主要是为了避免因为创建了多个实例造成资源的浪费，且多个实例由于多次调用容易导致结果出现错误，而使用单例模式能够保证整个应用中有且只有一个实例。

注意

在JAVA中单例模式可以有多种实现，包括常见的懒汉模式，即用时加载然后常驻内存，需synchronize修饰，或内部类方式。设计单例模式时应着重考虑其在多线程情况下不会创建多个实例。

实现

双重锁模式

public class Singleton {
    public static volatile Singleton singleton = null;
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if (singleton == null){//双重锁 保证两个线程同时会串行执行
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

内部类方式

public class SingletonInnerClass {
    //通过构建内部类实现延迟加载
    public static class SingletonHodler{
        private static SingletonInnerClass singleton = new SingletonInnerClass();
    }
    public static SingletonInnerClass getInstance(){
        return SingletonHodler.singleton;
    }
}

适配器模式

简介

适配器模式将一个类的接口转换成客户期望的另一个接口，适配器让原本接口不兼容的类可以相互合作。

注意

适配器的实现主要有三种方式：
类的适配器模式：当希望将一个类转换成满足另一个新接口的类时，可以使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口即可。

对象的适配器模式：当希望将一个对象转换成满足另一个新接口的对象时，可以创建一个Wrapper类，持有原类的一个实例，在Wrapper类的方法中，调用实例的方法就行。

接口的适配器模式：当不希望实现一个接口中所有的方法时，可以创建一个抽象类Wrapper，实现所有方法，我们写别的类的时候，继承抽象类即可。

实现

类的适配器模式

在不改变原有类的基础上，让原有的类拥有了新的方法，相当于实现了新的接口。

public class Source {  
  
    public void method1() {  
        System.out.println("this is original method!");  
    }  
}  
public interface Targetable {  
  
    /* 与原类中的方法相同 */  
    public void method1();  
  
    /* 新类的方法 */  
    public void method2();  
}  
public class Adapter extends Source implements Targetable {  
  
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
}  
public class AdapterTest {  
  
    public static void main(String[] args) {  
        Targetable target = new Adapter();  
        target.method1();  
        target.method2();  
    }  
}  

对象的适配器模式

实现了将一个对象转换为一个新对象的效果。

public class Wrapper implements Targetable {  
  
    private Source source;  
      
    public Wrapper(Source source){  
        super();  
        this.source = source;  
    }  
    @Override  
    public void method2() {  
        System.out.println("this is the targetable method!");  
    }  
  
    @Override  
    public void method1() {  
        source.method1();  
    }  
} 

public class AdapterTest {  
    public static void main(String[] args) {  
        Source source = new Source();  
        Targetable target = new Wrapper(source);  
        target.method1();  
        target.method2();  
    }  
}  

接口的适配器模式

即创建一个抽象类实现该接口，在创建类时继承该抽象类即可。

public interface Sourceable {  
      
    public void method1();  
    public void method2();  
}  
public abstract class Wrapper2 implements Sourceable{  
      
    public void method1(){}  
    public void method2(){}  
}  
public class SourceSub1 extends Wrapper2 {  
    public void method1(){  
        System.out.println("the sourceable interface's first Sub1!");  
    }  
}  
public class SourceSub2 extends Wrapper2 {  
    public void method2(){  
        System.out.println("the sourceable interface's second Sub2!");  
    }  
}  
public class WrapperTest {  
    public static void main(String[] args) {  
        Sourceable source1 = new SourceSub1();  
        Sourceable source2 = new SourceSub2();  
          
        source1.method1();  
        source1.method2();  
        source2.method1();  
        source2.method2();  
    }  
}  

装饰者模式

简介

装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

注意

装饰者模式可以简单理解为通过和目标类实现了同一个接口的装饰类，动态地为目标类的方法增加新的功能。

实现

interface Sourceable {  
    public void method();  
}  
public class Source implements Sourceable {  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  
public class Decorator implements Sourceable {  
  
    private Sourceable source;  
      
    public Decorator(Sourceable source){  
        super();  
        this.source = source;  
    }  
    @Override  
    public void method() {  
        System.out.println("before decorator!");  
        source.method();  
        System.out.println("after decorator!");  
    }  
}  
public class DecoratorTest {  
    public static void main(String[] args) {  
        Sourceable source = new Source();  
        Sourceable obj = new Decorator(source);  
        obj.method();  
    }  
}