首先说个题外话，《研磨设计模式》这本书占据很多设计模式书籍排行榜的榜首，但是这本书只印刷了一次，导致此书绝版，所以在淘宝和京东的购买价格翻了3倍

【简单工厂模式】

1.客户端根本就不应该知道具体的实现类是Impl，其实就是为了封装实现类，因而在具体实现类和客户端之间增加了一个工厂类，工厂类的作用就是用来选择

2.Factory应该根据某些条件去选择究竟创建哪一个具体的实现对象

3.简单工厂主要就是要创建一个简单工厂对象，让简单工厂来负责创建接口对象。然后让客户端通过工厂来获取接口对象，而不再由客户端自己去创建接口的对象了

4.使用配置文件，当有了新的实现类后，只要在配置文件里面配置上新的实现类即可

5.建议在一下情况中选用简单工厂

　　1）如果想要完全封装隔离具体实现，让外部只能通过接口来操作封装类，那么可以选用简单工厂，让客户端通过工厂来获取相应的接口，而无须关心具体的实现

　　2）如果想要把对外创建对象的职责集中管理和控制，可以选用简单工厂，一个简单工厂可以创建很多的、不相关的对象，可以把对外创建对象的职责集中到一个简单工厂来，从而实现集中管理和控制

6.抽象工厂模式是用来选择产品簇的实现的，也就是说一般抽象工厂里面有多个用于选择并创建对象的方法。如果抽象工厂退化成为只有一个实现，那么就相当于简单工厂了

7.工厂方法跟简单工厂的区别在于工厂方法是把选择具体实现的功能延迟到子类去实现

【外观模式】

1.接口，主要指的是外部和内部交互的一个通道，通常是指一些方法，可以是类的方法，也可以是interface的方法

2.外观模式的本质是：封装交互，简化调用

3.通过外观，子系统为外部提供一些高层的接口，以方便它们的使用

4.外观模式就是为了封装方法，值暴露接口

【适配器模式】

1.适配器模式的主要功能是进行转换匹配，目的是复用已有的功能，而不是来实现新的接口

2.适配器会把相应的功能委托给被适配的对象去完成

3.适配器模式就是为了解决兼容问题，而创建一个中间转换的类，用于跳转调用

【单例模式】

1.饿汉式在创建对象实例的时候就比较着急，于是就在装载类的时候就创建对象实例

2.Java里面实现的单例是一个虚拟机的范围，所以一个虚拟机在通过自己的ClassLoader装载饿汉式实现单例类的时候就会创建一个类的实例

3.static的特性：

　　1）static变量在类装载的时候进行初始化

　　2）多个实例的static变量会共享同一块内存区域

4.饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的

5.被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量

6.在某些情况下，JVM已经隐含地为您执行了同步，这些情况就不用你自己再来进行同步控制了：

　　1）由静态初始化器（在静态字段上或static{}块中的初始化器）初始化数据时

　　2）访问final字段时

　　3）在创建线程之前创建对象时

　　4）线程可以看见它将要处理的对象时

7.静态内部类实现单例的好处：由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。而且延迟初始化并没有增加任何访问成本

public class Singleton{/*** 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例没有绑定关系，而且只有被调用到时才会装载，从而实现了延迟加载**/private static class SingletonHolder{/*** 静态初始化器，由JVM来保证线程安全**/private static Singleton instance = new Singleton();}/*** 私有化构造方法**/private Singleton(){}public static Singleton getInstance(){return SingletonHolder.instance;}
}

【工厂方法模式】

1.工厂方法模式分为产品类集和工厂类集，产品类集包括一个接口和多个实现类，工厂类集包括一个抽象父类和多个继承子类，产品实现类和工厂实现类一一对应，工厂类创造产品，但创造的方法在工厂父类里，这里用到了控制反转的思想

2.工厂方法的实现中，通常父类会是一个抽象类，里面包含创建所需对象的抽象方法，这些抽象方法就是工厂方法

3.如果要在A里面使用C，当然是直接回创建C的对象，也就是说，在A类中主动去获取所需要的外部资源C，这种情况被称为正向的。那么什么是反向呢？就是A类不再主动去获取C，而是被动等待，等待IoC/DI的容器获取一个C的实例，然后反向地注入到A类中

4.依赖注入：应用程序依赖容器创建并注入它所需要的外部资源；而控制反转是从容器的角度去描述，描述得完整点就是：容器控制应用程序，由容器反向地向应用程序注入其所需要的外部资源

5.最简单的IoC/DI例子：

public class A{/*** 等待被注入进来**/private C c = null;/*** 注入资源C的方法* @param c 被注入的资源**/public void setC(C c){this.c = c;}public void t1{//这里需要使用C，可是又不让主动去创建C了，怎么办？//反正就要求从外部注入，这样更省心//自己不用管怎么获取C，直接使用就好了
        c.tc();}
}

6.工厂方法模式的缺点：

　　具体产品对象和工厂方法的耦合性：在工厂方法模式中，工厂方法时需要创建产品对象的，也就是需要选择具体的产品对象，并创建它们的实例，因此具体产品对象和工厂方法时耦合的

7.何时选用工厂方法模式：

　　1）如果一个类需要创建某个接口的对象，但是又不知道具体的实现，这种情况可以选用工厂方法模式，把创建对象的工作延迟到子类中去实现

　　2）如果一个类本身就希望由它的子类来创建所需的对象的时候，应该使用工厂方法模式

8.工厂方法模式的子类专注的是创建产品对象

【抽象工厂模式】

1.抽象工厂复杂度要大于工厂方法，工厂方法是一个工厂类集和一个产品类集，抽象工厂是一个工厂类集和多个产品类集，工厂的实现类分别从产品类集中各取一个实现，形成固定的组合，供客户端挑选

2.抽象工厂的功能是为一系列相关对象或相互依赖的对象创建一个接口

3.DAO：数据访问对象，是Data Access Object首字母的简写

4.抽象工厂的优点使得切换产品簇变得容易：因为一个具体的工厂实现代表的是一个产品簇，客户端选用不同的工厂实现，就相当于是在切换不同的产品簇

5.抽象工厂的缺点是容易造成层次复杂：如果需要选择的层次过多，整个抽象工厂的实现也需要分出层次来，每一层负责一种选择，也就是一层屏蔽一种变化，这样很容易造成复杂的类层次结构

6.何时选用抽象工厂模式

　　1）如果希望一个系统独立于它的产品的创建、组合和表示的时候。换句话说，希望一个系统只是知道产品的接口，而不关心实现的时候

　　2）如果一个系统要由多个产品系列中的一个来配置的时候。换句话说，就是可以动态地切换产品簇的时候

　　3）如果要强调一系列相关产品的接口，以便联合使用它们的时候

7.如果把抽象工厂创建的产品簇简化，这个产品簇就只有一个产品，那么这个时候的抽象工厂跟工厂方法时差不多的，也就是抽象工厂可以退化成工厂方法，而工厂方法又可以退化成简单工厂，这也是它们的联系

【生成器模式】

1.android的AlertDialog是典型的生成器模式，生成器模式就是把每个步骤都作为单独的实现，步骤可以有顺序，也可以没有顺序，所有步骤可以执行完，也可以不执行完，得到的都是一个完整的不一样的产品

2.生成器模式重在一步一步解决构造复杂对象的问题，这个构建过程是同一的、固定不变的，变化的部分放到生成器部分了，只要配置不同的生成器，那么同样的构建过程，就能构建出不同的产品来

3.生成器模式的中心在于分离构建算法和具体的构造实现

4.生成器模式分为两个很重要的部分

　　1）一个部分的Builder接口，这里是定义了如何构建各个部件，也就是知道每个部件功能如何实现，以及如何装配这些部件到产品中去

　　2）另外一个部分是Director，Director是知道如何组合来构建产品，也就是说Director负责整体的构建算法，而且通常是分步骤地来执行

5.使用Builder模式来构建复杂对象，考虑带约束规则。可以选择在构建器的build方法里面进行数据的整体校验

6.生成器模式的本质：分离整体构建算法和部件构造

【原型模式】

1.原型模式其实就是采用克隆，我觉得叫克隆模式更为贴切，注意下浅度克隆和深度克隆的区别（如果包含引用类型，就要深度克隆）另外Java自带了Cloneable接口

2.用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象

3.浅度克隆：只负责克隆按值传递的数据（比如基本数据类型、String类型）

4.深度克隆：除了浅度克隆要克隆的值外，还负责克隆引用类型的数据，基本上就是被克隆实例所有的属性数据都会被克隆出来

5.原型模式的优点：

　　1）对客户端隐藏具体的实现类型：原型模式的客户端只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类型的依赖

　　2）在运行时动态改变具体的实现类型：原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类

6.原型模式的缺点：原型模式最大的缺点就在于每个原型的子类都必须实现clone的操作，尤其在包含引用类型的对象时，clone方法会比较麻烦，必须要能够递归地让所有的相关对象都要正确地实现克隆

7.原型模式的重心还是在创建新的对象实例

【中介者模式】

1.中介者其实就是创建一个平台类或者管理类，每个实现类是单独封装的，实现类执行完成后回调通知平台类或管理类，由平台类或管理类进行接下来的操作

2.中介者的功能非常简单，就是封装对象之间的交互，集中控制这些对象的交互关系

3.在实际应用开发中，经常会简化中介者模式，来使开发变得简单，比如有如下的简化：

　　1）通常会去掉同事对象的父类，这样可以让任意的对象，只要需要相互交互，就可以成为同事

　　2）通常不定义Mediator接口，把具体的中介者对象实现成为单例

　　3）同事对象不再持有中介者，而是在需要的时候直接获取中介者对象并调用；中介者也不再持有同事对象，而是在具体处理方法里面去创建，或者获取，或者从参数传入需要的同事对象

把这样经过简化、变形使用的情况称为广义中介者

4.中介者模式的一个潜在缺点：过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到中介者的时候，会导致中介者对象变得十分复杂，而且难于管理和维护

5.中介者模式的本质：封装交互

【代理模式】

1.代理就是在实现类和客户端之间插了一个代理类，用于控制客户端对实现类的使用，相当于加了一道锁。其中动态代理是插件化中Hook经常用到的技术

2.Hibernate的LazyLoad就是使用代理来实现的

3.Java对代理模式提供了内建的支持，在java.lang.reflect包下面，提供了一个Proxy的类和一个InvocationHandler的接口

4.通常的Java静态代理有一个较大的缺点，就是如果Subject接口发生变化，那么代理类和具体的目标实现都要变化，不是很灵活。而使用Java内建的对代理模式支持的功能来实现则没有这个问题

5.通常把使用Java内建的对代理模式支持的功能来实现的代理称为Java的动态代理。动态代理跟静态代理相比，明显的变化是：静态代理实现的时候，在Subject接口上定义很多的方法，代理类里面自然也要实现很多方法；而动态代理实现的时候，虽然Subject接口上定义了很多方法，但是动态代理类始终只有一个invoke方法，这样，当Subject接口发生变化的时候，动态代理的接口就不需要跟着变化了

6.Java的动态代理目前只能代理接口，基本的实现是依靠Java的反射机制和动态生成class的技术，来动态生成被代理的接口的实现对象。代理类的实现

　　1）要实现InvocationHandler接口

　　2）需要提供一个方法来实现：把具体的目标对象和动态代理绑定起来，并在绑定好过后，返回被代理的目标对象的接口，以利于客户端的操作

　　3）需要实现invoke方法，在这个方法里面，具体判断当前是在调用什么方法，需要如何处理

/*** 使用Java中的动态代理**/public class DynamicProxy implements InvocationHandler{/*** 被代理的对象**/private OrderApi order = null;/*** 获取绑定好代理和具体目标对象后的目标对象的接口* @param order 具体的订单对象，相当于具体目标对象* @return 绑定好代理和具体目标对象后的目标对象的接口**/public OrderApi getProxyInterface(Order order){//设置被代理的对象，好方便invoke里面的操作this.order = order;//把真正的订单对象和动态代理关联起来OrderApi orderApi = (OrderApi)Proxy.newProxyInstance(order.getClass().getClassLoader(),order.getClass().getInterfaces(),this);return orderApi;}public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{//如果是调用setter方法就需要检查权限if(method.getName().startWith("set")){//如果不是创建人，那就不能修改if(order.getOrderUser()!=null && order.getOrderUser().equals(args[1])){//可以操作return method.invoke(order,args);}else{System.out.println("对不起，"+args[1]+",您无权修改本订单中的数据");}}else{//不是调用的setter方法就继续运行return method.invoke(order,args);}return null;}}

7.各个代理模式的特点：

远程代理：隐藏了一个对象存在于不同的地址空间的事实，也即是客户通过远程代理去访问一个对象，根本就不关心这个对象在哪里，也不关心如何通过网络去访问到这个对象。从客户的角度来讲，它只是在使用代理对象而已

虚代理：可以根据需要来创建“大”对象，只有到必须创建对象的时候，虚代理才会创建对象，从而大大加快程序运行速度，并节省资源。通过虚代理可以对系统进行优化

保护代理：可以在访问一个对象的前后，执行很多附加的操作，除了进行权限控制之外，还可以进行很多跟业务相关的处理，而不需要修改被代理的对象。也就是说，可以通过代理来给目标对象增加功能

智能指引：和保护代理类似，也是允许在访问一个对象的前后，执行很多附加的操作，这样一来就可以做很多额外的事情，比如，引用计数等

8.何时选用代理模式：

　　1）需要为一个对象在不同的地址空间提供局部代表的时候，可以使用远程代理

　　2）需要按照需要创建开销很大的对象的时候，可以使用虚代理

　　3）需要控制对原始对象的访问的时候，可以使用保护代理

　　4）需要在访问对象执行一些附加操作的时候，可以使用智能指引代理

【观察者模式】

1.观察者模式包括被观察的目标和观察者，目标接口和观察者接口分别持有对方接口的引用，目标实现类中注册了观察者实现类，当有状态变动时，就调用观察者实现类的方法，观察者实现类做相应的执行。Android中的广播发送和接收就是典型的观察者模式，最常见的框架就是Eventbus

2.具体的目标实现对象要能维护观察者的注册信息，最简单的实现方案就如同前面的例子那样，采用一个集合来保存观察者的注册信息

3.命名建议

　　1）观察者模式又被称为发布--订阅模式

　　2）目标接口的定义，建议在名称后面跟Subject

　　3）观察者接口的定义，建议在名称后面跟Observer

　　4）观察者接口的更新方法，建议名称为update，当然方法的参数可以根据需要定义，参数个数不限、参数类型不限

4.观察者模式两种类型

　　1）推模型：目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的信息通常是目标对象的全部或部分数据，相当于是在广播通信

　　2）拉模型：目标对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到目标对象中获取，相当于是观察者从目标对象中拉数据。一般这种模型的实现中，会把目标对象自身通过update方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了

5.推模型是假定目标对象知道观察者需要的数据；而拉模型是目标对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传给观察者，让观察者自己去按需取值

6.推模型可能会使得观察者对象难以复用，因为观察者定义的update方法是按需而定义的，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能需要提供新的update方法，或者时干脆重新实现观察者

7.Java中已有实现观察者模式，在java.util包里面有个类Observable，还有个接口Observer，其中定义了update的方法，就是观察者的接口

/*** 报纸对象，具体的目标实现**/public class NewsPaper extends java.util.Observable{/*** 报纸的具体内容**/private String content;/*** 获取报纸的具体内容* @return 报纸的具体内容**/public String getContent(){return content;}/*** 示意，设置报纸的具体内容，相当于出版报纸了* @param content 报纸的具体内容**/public void setContent(String content){this.content = content;//内容有了，说明又出新报纸了，那就通知所有的读者//注意在Java中的Observer模式的时候，下面这句话不可少this.setChanged();//然后主动通知，这里用的是推的方式this.notifyObservers(this.content);//如果用拉的方式，这么调用//this.notifyObservers();
      }}

 /*** 真正的读者，为了简单就描述一下姓名**/public class Reader implements java.util.Observer{/*** 读者的姓名**/private String name;public String getName(){return name;}public void setName(String name){this.name = name;}public void update(Observable o,Object obj){//这是采用推的方式System.out.println(name+"收到报纸了，阅读先。目标推过来的内容是==="+obj);}//这是获取拉的数据System.out.println(name+"收到报纸了，阅读它，主动到目标对象去拉的内容是==="+((NewsPaper)o).getContent());}

 public class Client{public static void main(String[] args){//创建一个报纸，作为被观察者NewsPaper subject = new NewsPaper();//创建阅读者，也就是观察者Reader reader1 = new Reader();reader1.setName("张三");Reader reader1 = new Reader();reader1.setName("李四");Reader reader1 = new Reader();reader1.setName("王五");//注册阅读者
         subject.addObserver(reader1);subject.addObserver(reader2);subject.addObserver(reader3);//要出报纸啦subject.setContent("本期内容是观察者模式");}}

8.观察者模式的优点

　　1）观察者模式实现了观察者和目标之间的抽象耦合

　　原本目标对象在状态发生改变的时候，需要直接调用所有的观察者对象，但是抽象出观察者接口以后，目标和观察者就只是在抽象层面上耦合了，也就是说目标只是知道观察者接口，并不知道具体的观察者的类，从而实现目标类和具体的观察者类之间解耦

　　2）观察者模式实现了动态联动

　　所谓联动，就是做一个操作会引起其他相关的操作。由于观察者模式对观察者注册实行管理，那就可以在运行期间，通过动态地控制注册的观察者，来控制某个动作的联动范围，从而实现动态联动

　　3）观察者模式支持广播通信

　　由于目标发送通知给观察者是面向所有注册的观察者，所以每次目标通知的信息就要对所有注册的观察者进行广播。当然，也可以通过在目标上添加新的功能来限制广播的范围

9.观察者模式的本质是触发联动

【命令模式】

1.命令模式其实就是：客户端-->调用者(含有多个命令)-->命令-->接收者(实现功能)，虽然这个流程看起来有些多余，但是很好的实现了客户端和接收者的解耦，命令用来中转

2.命令模式的关键之处就是把请求封装成为对象，也就是命令对象

3.可撤销操作的意思就是：放弃该操作，回到未执行该操作前的状态

　　1）一种是补偿式，又称反操作式

　　2）另外一种是存储恢复式

4.宏命令简单点说就是包含多个命令的命令，是一个命令的组合

5.队列请求就是对命令对象进行排队，组成工作队列，然后依次取出命令对象来执行。通常用多线程或者线程池来进行命令队列的处理

6.命令模式的本质是封装请求

7.命令模式的优点

　　1）更松散的耦合

　　命令模式使得发起命令的对象--客户端，和具体实现命令的对象--接收者对象完全解耦

　　2）更动态的控制

　　命令模式把请求封装起来，可以动态地对它进行参数化、队列和日志化等操作，从而使得系统更灵活

　　3）很自然的复合命令

　　命令模式中的命令对象能够很容易地组合成复合命令，也即是宏命令，从而使系统操作更简单，功能更强大

　　4）更好的扩展性

　　由于发起命令的对象和具体的实现完全解耦，因此扩展新的命令就很容易，只需要实现新的命令对象，然后在装配的时候，把具体的实现对象设置到命令对象中，然后就可以使用这个命令对象，已有的实现完全不用变化

8.常说命令模式可以实现Java回调

【迭代器模式】

1.迭代器模式就是Iterator，简化了for循环

2.迭代器模式的关键思想就是把对聚合对象的遍历和访问从聚合对象中分离出来，放入单独的迭代器中

3.双向迭代器：可以同时向前和向后遍历数据的迭代器。在Java util包中的ListIterator接口就是一个双向迭代器的示例

4.迭代器模式的本质：控制访问聚合对象中的元素

【组合模式】

1.Android中最常见的组合模式就是ViewGroup和View了，ViewGroup继承View，又包含View

2.组合模式的目的是：让客户端不再区分操作的是组合对象还是叶子对象，而是以一个统一的方式来操作。实现这个目标的关键之处，是设计一个抽象的组件类，让它可以代表组合对象和叶子对象

3.组合模式的本质：统一叶子对象和组合对象

【模板方法模式】

1.模板方法说的简单点就是把几个类中公共的部分抽出来作为父类，毕竟消灭重复代码是重构最基本的手段之一

2.排序的实现，实际上组合使用了模板方法模式和策略模式，从整体来看是模板方法模式，但到了局部，比如排序比较算法的实现上，就使用的是策略模式了

3.模板方法模式的优点是实现代码复用：模板方法模式是一种实现代码复用的很好的手段。通过把子类的公共功能提炼和抽取，把公共部分放到模板中去实现

4.模板方法模式的缺点是算法骨架不容易升级：模板方法模式最基本的功能就是通过模板的指定，把算法骨架完全固定下来。事实上模板和子类是非常耦合的，如果要对模板中的算法骨架进行变更，可能就会要求所有相关的子类进行相应的变化。

5.模板方法模式的本质：固定算法骨架

6.模板方法模式主要是通过制定模板，把算法步骤固定下来，至于谁来实现，模板可以自己提供实现，也可以由子类去实现，还可以通过回调机制让其他类来实现

【策略模式】

1.策略，顾名思义，就是方法。策略模式很类似工厂模式，只不过策略模式重点是多个方法（算法）的分离

2.策略模式的功能是把具体的算法实现从具体的业务处理中独立出来，把它们实现成为单独的算法类，从而形成一系列的算法，并让这些算法可以相互替换

3.策略模式的重心不是如何来实现算法，而是如何组织、调用这些算法，从而让程序结构更加灵活，具有更好的维护性和扩展性

4.策略算法是相同行为的不同实现

5.在策略模式中，通常是上下文使用具体的策略实现对象。反过来，策略实现对象也可以从上下文获取所需要的数据。因此可以将上下文当做参数传递给策略实现对象，这种情况下上下文和策略实现对象是紧密耦合的

6.策略模式的本质：分离算法，选择实现。因为分离并封装了算法，才能够很容易地修改和添加算法；也能很容易地动态切换使用不同的算法，也就是动态选择一个算法来实现需要的功能

7.模板方法重要封装算法骨架；而策略模式重在分离并封装算法实现

【状态模式】

1.状态模式就是根据同一个对象的不同状态执行不同的行为，高级点的行为实现可以控制下一个状态的实现内容

2.允许一个对象在器内部状态改变时改变它的行为。对象看起来似乎修改了它的类

3.还有一个方式来维护状态，那就是使用数据库，在数据库中存储下一个状态的识别数据

4.状态模式本质：根据状态来分离和选择行为

【备忘录模式】

1.备忘录：顾名思义，就是类似于游戏存档，手机或电脑重装系统之前的备份，一般用缓存或数据库实现

2.在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后旧可以将该对象恢复到原先保存的状态

3.备忘录模式中，捕获的内部状态存储在备忘录对象中；而备忘录对象通常会被存储在原发器对象之外，也就是被保存状态的对象的外部，通常是存放在管理者对象那里

4.通常会把备忘录对象作为原发器对象的内部类来实现，而且实现成私有的，这就断绝了外部来访问这个备忘录对象的途径

5.备忘录对象需要保存在原发器对象之外，为了与外部交互，通常备忘录对象都会实现一个窄接口，来标识对象的类型

6.标准的备忘录模式的实现机制是依靠缓存来实现的

7.备忘录模式的本质：保存和恢复内部状态

最终总结：

从16年开始到现在，也断断续续看了几本有关设计模式的书籍，但是总不得其要。其实代码本是这样，设计模式不过是代码级别的技巧而已，比最简单的框架还要低级别，不需要想的有多深奥有多复杂。所以我想接下来的几年，我都不会再看设计模式相关的书籍。那么，记住设计模式有没有什么技巧呢？我且斗胆用最最简单的词汇来汇总，以便记忆：

设计模式在我理解就是面向抽象三大特性：封装、继承、多态在不同业务情景下的代码逻辑，万变不离其宗，只要把封装继承多态用好了，写出来的代码自然而然就会形成设计模式 

欢迎关注我的微信公众号：安卓圈