Android源码设计模式解析与实战 笔记

面向对象的六大原则

1. 单一职责原则 single responsibility Principle：一个类中应该是一组相关性很高的函数、数据的封装

2. 开闭原则 Open close Principle ：软件中的对象（类、模块、函数等）应该对于扩展是开放的，但是对于修改是封闭的

3. 里式替换原则 Liskov Substitution Principle ：所有引用基类的地方必须能透明地使用其子类的对象

4. 依赖倒置原则 Dependence Inversion Prinviple：高层模块(调用方)不应该依赖低层模块(具体实现类)，两者都应该依赖其抽象，抽象不应该依赖细节(实现类，实现接口或者继承抽象类产生的类就是细节)，细节应该依赖抽象(接口或者抽象类)
   模块间的依赖通过抽象发生，实现类之间不发生直接的依赖关系，其依赖关系是通过接口或者抽象类产生的。。。就是A调用B的方法时，需要传递C参数，这个时候用C的父类接收，不要直接定义C参数类型

5. 接口隔离原则 InterfaceSegregation Principle ：客户端不应该依赖它不需要的接口，即类间的依赖关系应该建立在最小的接口上， 比如 outputStream.close() 就是实现AutoCloseable接口，这个接口里只有一个方法，close(),然后所有需要关闭的类都可以实现此接口。。

6. 迪米特原则 Law of Demeter 最少知识原则：一个对象应该对其他对象有最少的了解，即一个类应该对自己需要耦合或者调用的类知道的最少，类的内部如何实现与调用者或者依赖者没关系，调用者或者依赖者只需要知道它需要的方法即可
   比如，你要租房子，你只需要跟中介沟通即可，告诉中介你得需求，然后具体哪个房子，房东之间的交涉都不需要你参加。。

单例模式

确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例
单例模式有好多种实现方式，懒汉模式，DCL模式，静态内部类单例模式等
推荐静态内部类实现单例模式，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化

/**
 * @author 付影影
 * @desc
 * @date 2019/8/19
 */
public class SingleBean {
    private SingleBean() {
    }

    public static SingleBean getInstance() {
        return SingleHolder.mSigleBean;
    }
    
    private static class SingleHolder {
        private static final SingleBean mSigleBean = new SingleBean();
    }
}

上面的几种单例模式，在反序列化的情况下，都会被重新创建，通过序列化可以将一个单例的实例对象写到磁盘，然后再读回来，从而有效地获得一个实例，如果要想要控制这种情况，可以控制对象的反序列化，加入readResolve这个方法，或者使用枚举单例，枚举在Java中与普通类是一样的，不仅能够有字段，还能够有自己的方法，最重要的是默认枚举实例的创建是线程安全的，并且在任何情况下它都是一个单例。。。

 private Object readResolve() throws ObjectStreamException {
        return SingleHolder.mSingleBean;
    }

使用容器（Map）实现单例模式，就是将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象，通过统一接口进行获取操作，降低用户使用成本，隐藏具体实现，降低耦合度。。
单例模式的核心原理就是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全，防止反序列化导致重新生成实例对象等问题

责任链模式

直接跳到这个模式，因为今天在看okHtpp的源码，发现最后的核心 各种拦截器 就是用责任链模式实现的，所以就把责任链模式学习了一下。。
责任链模式的基础模型是swich—case，if-else,可能会有多个实现者，构成一个一个节点，每个节点看成一个对象，每个对象拥有不同的处理逻辑，节点连接起来，就形成链条
发送一个请求，从头开始遍历，沿着链的路径一次传递给每一个节点对象，直到有对象处理这个请求或者没有任何一个对象能处理，退出。。
责任链的优点就是对请求者和处理者的关系解耦，请求者不需要知道是哪个处理者处理了自己的请求，提高代码的灵活性
缺点就是需要对链中的处理者遍历，如果处理者太多，遍历肯定影响性能
Android中事件的分发 就是责任链模式实现的，从用户触摸屏幕的那刻开始，Android就将对应的事件 包装成一个事件对象，从viewTree的顶部 一层一层 由上至下 分发传递

/**
 * @author 付影影
 * @desc 员工想要报销，所有把报销单给组长，组长判断自己的权限，能处理就处理，不能处理就交给自己的上级处理
 * 一层层的传递下去，直到有对象处理，或者所有的对象都处理不了，退出。。
 * 在责任链模式中，请求发送者并不需要关心是谁处理了自己的请求，只需要拿到结果。。
 * 责任链模式 完美的 将请求发送者和处理者解耦
 * @date 2019/10/17
 */
public class WorkerFu {
    public static void main(String[] args) {
        //构造各级领导对象
        GroupLeader groupLeader = new GroupLeader();
        DirectorLeader directorLeader = new DirectorLeader();
        ManagerLeader managerLeader = new ManagerLeader();
        Boss boss = new Boss();

        //设置上一级领导处理者对象
        groupLeader.nextHandle = directorLeader;
        directorLeader.nextHandle = managerLeader;
        managerLeader.nextHandle = boss;

        //发起账单申请
        groupLeader.handler((int) Math.random() * 30000);

    }
}
======================================
/**
 * @author 付影影
 * @desc
 * @date 2019/10/17
 */
public abstract class Leader {
    //上一级领导处理者
    protected Leader nextHandle;

    public final void handleRequest(int money){
        if (money <= limit()){
            handler(money);
        }else {
            if (null != nextHandle){
                nextHandle.handleRequest(money);
            }
        }
    }

    /**
     * 领导可以处理的范围限制
     * @return
     */
    protected abstract int limit();

    /**
     * 领导的处理结果
     * @param money
     */
    protected abstract void handler(int money);
}
 ==============================

/**
 * @author 付影影
 * @desc
 * @date 2019/10/17
 */
public class GroupLeader extends Leader {
    @Override
    protected int limit() {
        return 1000;
    }

    @Override
    protected void handler(int money) {
        System.out.println("组长批复报销："+money+"元");
    }
}
 ===============================
/**
 * @author 付影影
 * @desc
 * @date 2019/10/17
 */
public class DirectorLeader extends Leader {
    @Override
    protected int limit() {
        return 5000;
    }

    @Override
    protected void handler(int money) {
        System.out.println("主管批复报销："+money+"元");
    }
}
========================================
/**
 * @author 付影影
 * @desc
 * @date 2019/10/17
 */
public class ManagerLeader extends Leader {
    @Override
    protected int limit() {
        return 10000;
    }

    @Override
    protected void handler(int money) {
        System.out.println("经理批复报销："+money+"元");
    }
}
========================================
/**
 * @author 付影影
 * @desc
 * @date 2019/10/17
 */
public class Boss extends Leader {
    @Override
    protected int limit() {
        return Integer.MAX_VALUE;
    }

    @Override
    protected void handler(int money) {
        System.out.println("老板批复报销：" + money + "元");
    }
}