Java复习笔记-设计模式

java 中的设计模式共23种，此处我只记录下Android开发过程中常用的比较重要的8种：

                单例模式

                观察者模式

                适配器模式

                工厂方法模式

                抽象工厂模式

                装饰着模式

                策略模式

                建造者模式

（-）单例模式

        动态确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。

           优点：                    

                   1.1、由于单例模式在内存中只有一个实例，减少了内存开销。对于那些耗内存的类，只实例化一次，大大提高性能，尤其是移动开发中。

                   1.2、单例模式可以避免对资源的多重占用，例如一个写文件时，由于只有一个实例存在内存中，避免对同一个资源文件的同时写操作。

                   1.3、单例模式可以向整个系统提供这个实例，优化和共享资源访问。

            分类：

                    1、饿汉式（线程安全）                       

public class Single_E {

    /**
     * 分析：
     * 1、私有化,静态对象，外界不可拿到，并且声明对象的时候就进行实例化
     * 2、私有化构造方法，外界不可创建实例
     * 3、对外提供共有的静态的方法来获取实例
     */


    //1、私有化,静态对象，外界不可拿到，并且上来就进行实例化
    private static Single_E instance= new Single_E();

    //2、私有化构造方法，外界不可创建实例
    private Single_E() {
    }

    //3、对外提供共有的静态的方法来获取实例
    public static Single_E getInstance() {
        return instance;
    }
}

                    2、懒汉式

public class Single_L {
    /**
     * 分析：
     * 1、私有化，静态对象，外界拿不到；先只声明对象，不创建实例，在需要的时候在创建实例
     * 2、私有化构造方法，防止外界创建实例
     * 3、向外界提供公有的、静态的方法来获取实例，需要考虑线程安全性问题
     */

    //1、私有化，静态对象，外界拿不到；先只声明对象，不创建实例，在需要的时候在创建实例
    private static Single_L instance = null;

    //2、私有化构造方法，防止外界创建实例
    private Single_L() {
    }

    //3、向外界提供公有的、静态的方法来获取实例，需要考虑线程安全性问题
    public static Single_L getInstance() {
        if (instance == null) {
            instance = new Single_L();
        }
        return instance;
    }
}

   （二）观察者模式

               当一个对象发生变化，那么依赖这个对象的其他对象会收到通知并且随之改变

               主要包括四个部分：

　                    　1. Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
　                     　2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。
　　                     3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。

　　                     4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。

               以下用一个小例子来说明实现过程：

                  1、创建一个接口作为观察者

/**
 * 作者：sunny on 2018/4/15 16:04
 * 说明：1、观察者接口
 *
 * 观察者模式定义：当一个对象放生变化,那么依赖这个对象的其他对象会收到通知,
 * 并且随之改变,是一种”一对多关系”
 */
public interface ObserverListener {

    void updateNews(String news);//有消息来了，为每个注册用户更新消息

}

                2、创建一个接口作为被观察者接口        

/**
 * 作者：sunny on 2018/4/15 16:32
 *
 * 说明：被观察者接口
 */

public interface SubjectListener {

    void regist(ObserverListener observerListener);//注册监听

    void unRegist(ObserverListener observerListener);//取消注册

    void notifyAllUser(String news);//通知注册用户更新消息

}

                3、接下来创建一个类，实现被观察者接口，用来做具体的处理

/**
 * 作者：sunny on 2018/4/15 16:34
 * 说明：观察者管理者（具体被观察者）
 */

public class ObserverManager implements SubjectListener {

    private static ObserverManager observerManager = new ObserverManager();

    private ObserverManager() {
    }

    /**
     * 单例模式--饿汉式
     *
     * @return
     */
    public static ObserverManager get() {
        return observerManager;
    }

    //观察者接口集合
    private List list = new ArrayList<>();


    @Override
    public void regist(ObserverListener observerListener) {
        if (observerListener != null) {
            list.add(observerListener);
        }

    }

    @Override
    public void unRegist(ObserverListener observerListener) {
        if (observerListener != null) {
            list.remove(observerListener);
        }
    }


    /**
     * 通知观察者刷新数据
     *
     * @param news
     */
    @Override
    public void notifyAllUser(String news) {
        for (ObserverListener observerListener : list) {
            observerListener.updateNews(news);
        }
    }
}

                    4、写几个类，继承观察者接口，实现updateNews方法，在该方法里接收新消息，根据业务做相应的处理。

/**
 * 作者：sunny on 2018/4/15 16:11
 * 说明：注册者--用户（具体观察者）
 */

public class Obverser_persion1 implements ObserverListener {

    @Override
    public void updateNews(String news) {

        Log.e("Observer", "我是产品经理，我收到新消息了:" + news);
    }
}

                    5、接下来就可以看下实现结果了

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);


    textOberser();//测试——观察者模式

}


/**
 * 测试——观察者模式
 */
private void textOberser() {

    //用户注册消息监听
    Obverser_persion1 persion1 = new Obverser_persion1();
    ObserverManager.get().regist(persion1);

    Obverser_persion2 persion2 = new Obverser_persion2();
    ObserverManager.get().regist(persion2);

    //有新消息，通知所有注册用户
    ObserverManager.get().notifyAllUser("消息1、、、");

}

日志：

04-15 09:17:25.165 8874-8874/com.java_design_model E/Observer: 我是产品经理，我收到新消息了:消息1、、、
04-15 09:17:25.165 8874-8874/com.java_design_model E/Observer: 我是人事，我收到新消息了: 消息1、、、

                说明：android中的广播接收器、还有ListView一类所使用的Adapter里的notifyDataSetChanged（）就是一种观察者模式。

（三）适配器模式

            定义：

                    把一个类的接口换成客户所期待的另一种接口，从而使原本因接口不匹配而无法在一起工作的两个类能够在一起工作了。

            使用场景：

                    1、系统徐亚使用现有类，而此类的接口不符合系统要求，即接口不兼容

                    2、想要建立一个重复使用的类，用于一些彼此之间没有太大关联的一些类，包括一些kennel子啊将来引进的类一起工作

                    3、需要一个统一的输出接口，而输入端的类型不可预知

            分为三个角色：

                    Target：目标角色，也就是所期待的到的接口。

                    Adaptee：现在需要适配的接口

                    Adapter：适配器角色，也就是本模式的核心。适配器把原接口转换成目标接口。显然这一角色不可以是接口，而是具体的类

            分类：

                    1、类适配器模式

                    2、对象适配器模式