大话设计模式（读后感）——23种设计模式、六大原则

一、设计模式之六大原则

　　1、单一职责原则(SRP：Single responsibility principle)

　　　　　就一个类而言，应该仅有一个引起它变化的原因； 通俗的说，即一个类只负责一项职责

　　　　分析：

　　　　　　1、如果一个类承担的职责过多，就等于把这些职责耦合在一起，一个职责的变化可能会削弱或者抑制这个类完成其他职责的能力；

　　　　　　 这种耦合会导致脆弱的设计，当变化发生时，设计会遭受到意想不到的破坏。

　　　　　　2、软件设计真正要做的许多内容，就是发现职责并把那些职责相互分离。

　　　　　　3、如果你能够想到多于一个的动机去改变一个类，那么这个类就具有多于一个的职责。

　　2、开放-封闭原则（OCP：Open Closed Principle）

　　　　 是说软件实体（类、模块、函数等等）应该可以扩展，但是不可以修改；

　　　　　　特征1：对于扩展是开放的（Open for extension）；

　　　　　　特征2：对于更改是封闭的（Closed for modification）。

　　　　分析：

　　　　　　1、在我们最初编写代码时，假设变化不会发生；当变化发生时，我们就创建抽象来隔离以后发生的同类变化。

　　　　　　2、面对需求，对程序的改动是通过增加新代码进行的，而不是更改现有的代码。

　　　　　　3、我们希望的是在开发工作展开不久就知道可能发生的变化，查明可能发生的变化所等待的时间越长，要创建正确的抽象就越难。

　　　　　　4、开发-封闭原则是面向对象设计的核心所在。 遵循此原则可以带来 可维护、可扩展、可复用、灵活性好的好处；

　　　　　　　　开发人员应该仅对程序中呈现出频繁变化的那些部分做出抽象，然而，对于应用呈现中的每个部分都刻意地进行抽象同样不是一个好主意；

　　　　　　　　　　拒绝不成熟的抽象和抽象本身一样重要。

　　3、依赖倒转原则（）

　　　　　A.高层模块不应该依赖低层模块。两个都应该依赖抽象

　　　　　B.抽象不应该依赖细节，细节应该依赖抽象

　　　　分析：

　　　　　　1、就是要针对接口编程，不要对实现编程　　　　　　

　　　　　　　 无论主板、CUP、内存都是在针对接口设计的，如果针对实现来设计，内存就要应对到具体的某个品牌的主板，那就会出现换内存需要把主板也换了的尴尬；

　　　　　　2、高层模块不应该依赖低层模块，两者都应该依赖其抽象又如何理解呢？这个问题也可以这么问：为什么要叫倒置(倒转)呢？

　　　　　　　　　　在面向过程的开发中，为了使用常用的代码可以复用，一般都会把这些常用的代码写成许许多多函数的程序库，这样我们做新项目的时候，

　　　　　　　　就去调用这些函数就可以了。

　　　　　　　　 例如：我们做的项目大多要访问数据库，所以我们就把数据库的代码写成了函数，每次做新项目时就去调用这些函数，这也就是高层依赖于低层模块了。

　　　　　　　　　　如果我们的高层模块和低层模块都依赖于抽象，具体一点就是依赖于接口或抽象类，只要接口够稳定，那么任何一个的更改都不用担心其他受到影响了。

　　4、里氏代换原则（）

　　　　　子类型必须能够替换掉它们的父类型

　　　　　 既：一个软件实体如果使用的是一个父类的话，那么一定适用于其子类，而其它察觉不出父类对象和子类对象的区别。

　　　　　　　　也就是说，在软件里面，把父类都替换成它都替换成它的子类，程序的行为没有变化。

　　　　分析：

　　　　　　1、正因为有这个原则，使得继承复用成为了可能，

　　　　　　　　只有当子类可以替换掉父类，软件单位的功能不受到影响时，父类才能真正被复用，而子类也能够在父类的基础上增加新的行为。

　　　　　　2、正是由于子类型的可替换性才使得使用父类类型的模块在无需修改的情况下就可以扩展。

　　　　　　3、依赖倒转其实可以说是面向对象设计的标志，用哪种语言来编写程序不重要，如果编写时考虑的都是如何针对抽象编程而不是针对细节编程，

　　　　　　　　即使程序中所有的依赖关系都是终止于抽象类或者接口，那就是面向对象的设计，反之那就是过程化的设计了。

　　5、迪米特法则（LKP：Least Knowledge Principle，又叫最少知识原则）

　　　　 如果两个类不必彼此直接通信，那么这两个类就不应当直接的相互作用；如果其中一个类需要调用另一个类的某一个方法的话，可以通过第三者转发这个调用。

　　　　分析：

　　　　　 1、在类的结构设计上，每一个类都应当尽量降低成员的访问权限；

　　　　　　2、其根本思想是强调了类之间的松耦合；

　　　　　　3、类之间的耦合越弱，越有利于复用，一个处于弱耦合的类被修改，不会对有关系的类造成波及。

　　6、合成/聚合复用原则

　　　　　尽量使用合成/聚合,尽量不要使用类继承

　　　　　优先使用对象的合成/聚合将有助于你保持每个类被封装，并被集中在单个任务上；

　　　　　这样类和类继承层次会保持较小规模，并且不太可能增长为不可能控制的庞然大物。

　　　　分析：

　　　　　　1、合成（Composition）和聚合（Aggregation）都是关联的特殊种类；

　　　　　　2、聚合表示一种弱的“拥有”关系，体现的是A对象可以包含B对象，但B对象不是A对象的一部分；

　　　　　　3、合成则是一种强的“拥有”关系，体现了严格的部分和整体的关系，部分和整体的生命周期一样

二、Java中的23种设计模式

　　1、单例模式——有些类也需要计划生育

　　　　　　保证一个类仅有一个实例，并提供一个访问它的全局访问点。

　　　　　　所有类都有构造方法，不编码则系统默认生成空的构造方法，若有显示定义的构造方法，默认的构造方法就会失效。

　　　　分析：

　　　　　　1、通常我们可以让一个全局变量使得一个对象被访问，但它不能防止你实例化多个对象；

　　　　　　　　一个最好的办法就是，让类自身负责保存它的唯一实例；这个类可以保证没有其他实例可以被创建，并且它可以提供一个访问该实例的方法。

　　　　　　2、单例模式因为Singleton类封装了它的唯一实例，这样它可以严格地控制客户怎样访问它以及何时访问它。简单地说就是对唯一实例的受控访问。

　　　　实用类与单例区别？

　　　　　　　　比如实用类不保存状态，仅提供一些静态方法或静态属性让你使用，而单例类是有状态的；实用类不能用于继承多态，而单例虽然实例唯一，却是可以有子类来继承。

　　　　　　实用类只不过是一些方法属性的集合，而单例却是有着唯一的对象实例。

　　　　懒汉式单例类：可以延迟加载，多线程不安全

//懒汉式
public class Singleton{
private static Singleton instance;

private Singleton(){}

public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
}

　　　　饿汉式单例类：线程安全，加载类时就初始化完成不能延迟加载

public class Singleton {
private static Singleton instance = new Singleton();

private Singleton(){}

public static Singleton getInstance(){
return instance;
}
}

　　　　双重检查：多线程安全、延迟加载，同步耗时

public class Singleton {

private static Singleton instance ;

private Singleton(){}

public static Singleton getInstance(){
if (instance == null){
synchronized (Singleton.class){
if (instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}

　　　　静态内部类：多线程安全，延迟加载，比（双重检查）少耗时

public class Singleton {

private Singleton(){}

public static Singleton getInstance(){
return SingletonHolder.instance;
}

private static class SingletonHolder {
private static Singleton instance = new Singleton();
}
}

　　　　用缓存实现：线程安全，占用内存大

public class Singleton {

private static final String KEY = "instance";

private static Map<String, Singleton> map = new HashMap<>();

private Singleton(){}

public static Singleton getInstance(){
Singleton singleton ;
if (map.get(KEY) == null){
singleton = new Singleton();
map.put(KEY, singleton);
} else {
singleton = map.get(KEY);
}
return singleton;
}
}

　　　

　　2、简单工厂模式——代码无错就是优？

　　　　　　简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。

　　　　　　应该考虑用一个单独的类来做这个创造实例的过程，这就是工厂

　　　　分析：

　　　　　　1、简单运算工厂类：

　　　　　　2、客户端代码：

　　　　所有在用简单工厂的地方，都可以考虑用反射技术来去除switch或if，解除分支判断带来的耦合

　　3、工厂方法模式——雷锋依然在人间

　　　　　　工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。

　　　　　　定义一个用于创建对象的接口，让子类决定实例化哪一个类； 使得一个类的实例化延迟到其子类。

　　　　分析：

　　　　　　1、简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

　　　　　　2、工厂方法模式实现时，客户端需要决定实例化哪一个工厂来实现运算类，选择判断的问题还是存在的，

　　　　　　　　也就是说工厂方法把简单工厂的内部逻辑判断移动到了客户端代码来进行。你想要加功能，本来是改工厂类，而现在是修改客户端。

　　4、抽象工厂模式——就不能不换DB吗？

　　　　　　抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。

　　　　　　它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

　　　　分析：

　　　　　　1、好处一是 易于交换产品系列，由于具体工厂类，例如：IFactory factory = new AccessFactory()，在一个应用中只需要在初始化的时候出现一次，

　　　　　　　　这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。

　　　　　　2、好处二是 让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操作实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

　　5、策略模式——商场促销

　　　　　　它定义了算法家族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化，不会影响到使用算法的客户

　　　　分析：

　　　　　　

　　6、装饰模式——穿什么有这么重要？

　　　　　　动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活

　　　　分析：

　　　　　　

　　7、原型模式——简历复印

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

　　　　　　原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需要指定任何创建的细节

　　　　分析：

　　　　　　

　　8、模板方法模式——考题抄错会做也白搭

　　　　　　定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤

　　　　分析：

　　　　　　

　　9、外观模式——牛市股票还会亏钱？

　　　　　　为子系统中的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这一子系统更加容易使用

　　　　分析：

　　　　　　

　　10、建造者模式——好菜每回味不同

　　　　　　将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

　　　　分析：

　　　　　　

　　11、观察者模式——老板回来，我不知道

　　　　　　定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象；

　　　　　　这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己

　　　　分析：

　　　　　　

　　12、状态模式——无尽加班何时休

　　　　　 当一个对象的内在状态改变时允许改变其行为，这个对象看起来像是改变了其类

　　　　　　主意解决：当控制一个对象状态转换的条件表达式过于复杂时的情况；把状态的判断逻辑移到表示不同状态的一系列类当中，可以把复杂的判断逻辑简化

　　　　分析：

　　　　　　

　　13、适配器模式——在NBA我需要翻译

　　　　　　将一个类的接口转换成客户希望的另外一个接口；Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

　　　　分析：

　　　　　　

　　14、备忘录模式——如果再回到从前

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

　　　　分析：

　　　　　　　

　　15、组合模式——分公司=一部门

　　　　　　将对象组合成树形结构以表示'部分-整体'的层次结构；组合模式使得用户对于单个对象和组合对象的使用具有一致性

　　　　分析：

　　　　　　

　　16、迭代器模式——想走？可以！先买票

　　　　　　提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示

　　　　分析：

　　　　　　

　　17、桥接模式——手机软件何时统一

　　　　　　将抽象部分与它的实现部分分离，使它们都可以独立地变化

　　　　　　什么叫抽象与它的实现分离，这并不是说，让抽象类与其派生类分离，因为这没有任何意义；实现指的是抽象类和它的派生类用来实现自己的对象

　　　　分析：

　　　　　　

　　18、命令模式——烤肉串引来的思考

　　　　　　将一个请求封装为一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或记录请求日志，以及支持可撤销的操作

　　　　分析：

　　　　　　

　　19、职责链模式——加薪非要老总批？

　　　　　　使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系；

　　　　　　将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止

　　　　分析：

　　　　　　

　　20、中介者模式——世界需要和平

　　　　　　用一个中介对象来封装一系列的对象交互；

　　　　　　中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互

　　　　分析：

　　　　　　

　　21、亨元模式——项目多也别傻做

　　　　　　运用共享技术有效地支持大量细粒度的对象

　　　　　　可以避免大量非常相似类的开销

　　　　分析：

　　　　　　1、有时需要大量细粒度的类实例来表示数据，如果能发现这些实例除了几个参数外基本上都是相同的，有时就能够受大幅度地减少需要实例化的类的数量；

　　　　　　　　如果能把那些参数移到类实例的外面，在方法调用时将它们传递进来，就可以通过共享大幅度地减少单个实例的数目

　　　　　　

　　22、解释器模式——其实你不懂老板的心

　　　　　　给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子

　　　　分析：

　　　　　　1、当有一语言需要解释执行，并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式

　　23、访问者模式——男人和女人

　　　　　　表示一个作用于某对象结构中的各元素的操作；

　　　　　　它使你可以在不改变各元素的类的前期下定义作用于这些元素的新操作

　　　　分析：

　　　　　　

　　24、代理模式——为别人做嫁衣

　　　　　　 为其他对象提供一种代理以控制对这个对象的访问

　　　　分析：