——可复用面向对象软件的基础
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。 希望广大程序爱好者，学好设计模式，做一个优秀的软件工程师！
一、设计模式的分类 总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
其实还有两类：并发型模式和线程池模式。用一个图片来整体描述一下：
1、开闭原则（Open Close Principle）
开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。
2、里氏代换原则（Liskov Substitution Principle）
里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科
3、依赖倒转原则（Dependence Inversion Principle）
这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。
4、接口隔离原则（Interface Segregation Principle）
这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。
5、迪米特法则（最少知道原则）（Demeter Principle）
为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。
6、合成复用原则（Composite Reuse Principle）
原则是尽量使用合成/聚合的方式，而不是使用继承。
三、Java的23中设计模式 —工厂模式 工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。 引言:- 1）还没有工厂时代：假如还没有工业革命，如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车，然后拿来用。
- 2）简单工厂模式：后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。
- 3）工厂方法模式时代：为了满足客户，宝马车系列越来越多，如320i，523i,30li等系列一个工厂无法创建所有的宝马系列。于是由单独分出来多个具体的工厂。每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。
4）抽象工厂模式时代：随着客户的要求越来越高，宝马车必须配置空调。于是这个工厂开始生产宝马车和需要的空调。
最终是客户只要对宝马的销售员说：我要523i空调车，销售员就直接给他523i空调车了。而不用自己去创建523i空调车宝马车.
这就是工厂模式。
- 1、简单工厂模式（Simple Factory）:
- 2、工厂方法模式（Factory Method）:
- 3、抽象工厂模式（Abstract Factory): 这三种模式从上到下逐步抽象，并且更具一般性。 GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。
简单工厂模式：又称静态工厂模式 目的:定义一个用于创建对象的接口 缺点:不利于生产系列商品
在简单工厂模式中， 工厂类处于产品类实例化调用的中心位置。工厂类决定哪一个产品类应当被实例化， 如同一个交警在十字路口， 决定各个方向的车辆的行驶的方向。 简单工厂模式的组成：
- 工厂类角色: 是本模式的核心，具有一定的商业逻辑和判断逻辑。 在java中它往往由一个具体实现。
- 抽象产品角色: 它一般是产品继承的父类或所实现的接口。在java中由接口或抽象类来实现。
- 具体产品角色: 工厂类所创建的对象就是此角色的实例。 在java中由一个具体类实现。
在工厂时代以前： 如果你想要一款宝马车，通常是我们自己去创造一个，然后使用 从无到有的过程。
package com.chb.bean;
public class BMW320 {
public BMW320() {
System.out.println("create a BMW320 car");
}
}
package com.chb.bean;
public class BMW523 {
public BMW523() {
System.out.println("create a BMW523 car");
}
}
package com.chb.factoryDEsingPattern_NoFactory;
import com.chb.bean.BMW320;
import com.chb.bean.BMW523;
/**
在工厂时代以前： 如果你想要一款宝马车，通常是我们自己去创造一个，然后使用
从无到有的过程。
*/
public class Customer {
public static void main(String[] args) {
BMW320 bmw320 = new BMW320();
BMW523 bmw523 = new BMW523();
}
}但是， 客户要直到如何创造一款车，这导致了客户和车紧密耦合在一起了，我要使用一个产品，必须要知道创建这个商品的细节，对于客户是不可忍受的。
为了降低耦合就出现了工厂类， 把创建宝马的细节放到工厂中，客户直接使用工厂的创建工厂方法，传入想要的宝马型号，而不用考虑创建的细节，这就是工业革命了：简单工厂模式,如下图：
5、工厂模式 产品类：abstract class BMW {
public BMW(){
}
}
public class BMW320 extends BMW {
public BMW320() {
System.out.println("制造-->BMW320");
}
}
public class BMW523 extends BMW{
public BMW523(){
System.out.println("制造-->BMW523");
}
} 工厂类角色，本模式的核心， 含有一定的商业逻辑或判断逻辑，用来创建商品。 在本例中， 判断传入的产品类型， 工厂生产对应的宝马车型。
public class Factory {
//工厂模式中的工厂类，违背了开闭原则（对扩展开发，对修改封闭），因为当客户不在满足现有的车型， 想要一种新的车型， 而这种车型符合抽象产品（BMW）的制作体系，那么就要在工厂类中添加这种新的车型，就必须修改createBMW（）方法，添加新车型，这违背了开闭原则。
public BMW createBMW(int type) {
switch (type) {
case 320:
return new BMW320();
case 523:
return new BMW523();
default:
break;
}
return null;
}
} public class Customer {
public static void main(String[] args) {
Factory factory = new Factory();
BMW bmw320 = factory.createBMW(320);
BMW bmw523 = factory.createBMW(523);
}
} 工厂模式中的工厂类，违背了开闭原则（对扩展开发，对修改封闭），因为当客户不在满足现有的车型， 想要一种新的车型， 而这种车型符合抽象产品（BMW）的制作体系，这要创建一个新的产品类，实现抽象产品（BMW）, 但在工厂类中添加这种新的车型，就必须修改createBMW()方法，添加新车型，这违背了开闭原则。可想而知，对如新加入的产品，工厂类是被动的。对于这样的工厂类，我们称它为全能类或者上帝类。 我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。
6、工厂方法模式工厂方法模式作为救世主出现了。 工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。 工厂方法模式组成：
- 1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
- 2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
- 3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
- 4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
产品类和简单工厂模式中的一致， 在此不在列出。
工厂类 抽象工厂类package com.chb.factoryDEsingPattern_FactoryMethod;
import com.chb.bean.BMW;
/**
抽象工厂角色：工厂方法模式的核心，与应用程序无关，是具体工厂角色必须实现的
接口或者抽象类，
*/
public interface FactoryBMW {
BMW createBMW(); //提供一个业务， 创建BMW,
} 每次新增一种新的车型，我们只需要创建一个对应的新的具体工厂类， 用于创建新的具体产品，不用修改原有的工厂类， 这保证了开闭原则。
package com.chb.factoryDEsingPattern_FactoryMethod;
import com.chb.bean.BMW320;
/**
具体工厂角色：含有与具体业务逻辑（创建产品）相关的代码
由引用程序的调用以创建对应的具体产品（如BMW320）。
*/
public class FactoryBMW320 implements FactoryBMW{
@Override
public BMW320 createBMW() {
return new BMW320();
}
}
public class FactoryBMW523 implements FactoryBMW {
@Override
public BMW523 createBMW() {
return new BMW523();
}
} package com.chb.factoryDEsingPattern_FactoryMethod;
import com.chb.bean.BMW320;
import com.chb.bean.BMW523;
/**
客户只需要从具体工厂提取所需的车子，就可以使用
新增一个新的车型， 如宝马30li， 因为是宝马系列，
所以符合抽象产品的合同
只有创建一个新的具体产品类BMW30li, 和一个生产BMW30li的工厂BMW30liFactory
客户就可以通过BMW30liFactory获取BMW30li，
*/
public class Customer {
public static void main(String[] args) {
FactoryBMW320 factoryBMW320 = new FactoryBMW320();
BMW320 bmw320 = factoryBMW320.createBMW();
FactoryBMW523 factoryBMW523 = new FactoryBMW523();
BMW523 bmw523 = factoryBMW523.createBMW();
}
} 工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多具体的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。 反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。
五、抽象工厂模式
