GoF（Gang of Four）:四人组,《Design Patterns: Elements of Reusable Object-Oriented Software》（《设计模式》)的作者,设计了23种设计模式.但时代发展,还有其它的设计模式，比如：JavaEE的设计模式（DAO模式、MVC模式等）。
● GoF23种设计模式可分为三大类：
○ 创建型（5个）：解决对象创建问题。
■ 单例模式
■ 工厂方法模式
■ 抽象工厂模式
■ 建造者模式
■ 原型模式
○ 结构型（7个）：一些类或对象组合在一起的经典结构。
■ 代理模式
■ 装饰模式
■ 适配器模式
■ 组合模式
■ 享元模式
■ 外观模式
■ 桥接模式
○ 行为型（11个）：解决类或对象之间的交互问题。
■ 策略模式
■ 模板方法模式
■ 责任链模式
■ 观察者模式
■ 迭代子模式
■ 命令模式
■ 备忘录模式
■ 状态模式
■ 访问者模式
■ 中介者模式
■ 解释器模式
● 工厂模式是解决对象创建问题的，所以工厂模式属于创建型设计模式。这里为什么学习工厂模式呢？这是因为Spring框架底层使用了大量的工厂模式。
为什么学工厂模式?
Spring底层就是通过工厂模式+XML+反射机制实现的.
工厂模式的三种形态
**● 第一种：简单工厂模式（Simple Factory）：不属于23种设计模式之一。简单工厂模式又叫做：静态工厂方法模式。简单工厂模式是工厂方法模式的一种特殊实现。**一个工厂对应一种产品.
● 第二种：工厂方法模式（Factory Method）：是23种设计模式之一。一个工厂对应多种产品.
● 第三种：抽象工厂模式（Abstract Factory）：是23种设计模式之一。一个工厂对应多种产品系列.
简单工厂模式
Spring中的BeanFactory就使用了简单工厂模式。
简单工厂模式的角色包括三个：
● 工厂类 角色
● 抽象产品 角色
● 具体产品 角色
简单工厂模式的优点：
● 客户端程序不需要关心对象的创建细节，需要哪个对象时，只需要向工厂索要即可，初步实现了责任的分离。客户端只负责“消费”，工厂负责“生产”。生产和消费分离。
简单工厂模式的缺点：
● 缺点1：工厂类集中了所有产品的创造逻辑，形成一个无所不知的全能类，有人把它叫做上帝类。显然工厂类非常关键，不能出问题，一旦出问题，整个系统瘫痪。
● 缺点2：不符合OCP开闭原则，在进行系统扩展时，需要修改工厂类。
//抽象产品角色weapon
package com.sunsplanter.factory;
//抽象类无法被创建对象,无法实例化,是用来被子类继承的
//Tank和Weapon是is-a的关系
//且基本功能在不断变化(开炮/投弹),因此用抽象类
public abstract class Weapon {/*** 所有的武器都有攻击行为*/public abstract void attack();
}
//具体产品角色tank/Fighter
package com.sunsplanter.factory;public class Tank extends Weapon{@Overridepublic void attack() {System.out.println("坦克开炮！");}
}```java
package com.sunsplanter.factory;public class Fighter extends Weapon{@Overridepublic void attack() {System.out.println("战斗机投下原子弹！");}
}
//工厂类角色
package com.sunsplanter.factory;public class WeaponFactory {/*** 根据不同的武器类型生产武器* @param weaponType 武器类型* @return 武器对象*/public static Weapon get(String weaponType){if (weaponType == null || weaponType.trim().length() == 0) {return null;}Weapon weapon = null;if ("TANK".equals(weaponType)) {weapon = new Tank();} else if ("FIGHTER".equals(weaponType)) {weapon = new Fighter();} else {throw new RuntimeException("不支持该武器！");}return weapon;}
}
package com.powernode.factory;public class Client {public static void main(String[] args) {Weapon weapon1 = WeaponFactory.get("TANK");weapon1.attack();Weapon weapon2 = WeaponFactory.get("FIGHTER");weapon2.attack();}
}
工厂方法模式
简单工厂违背了开闭原则,即每次扩展系统时,都要修改工厂类…工厂方法模式的将简单工厂模式的工厂类解耦为抽象工厂+具体工厂,每次扩展系统只要实现一次抽象工厂的接口就可以,不必修改原有程序.
工厂方法模式的角色包括：
● 抽象工厂角色
● 具体工厂角色
● 抽象产品角色
● 具体产品角色
工厂方法模式的优点：
● 一个调用者想创建一个对象，只要知道其名称就可以了。
● 扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
● 屏蔽产品的具体实现，调用者只关心产品的接口。
工厂方法模式的缺点：
● 每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
可以看到简单工厂和工厂方法的区别只在于:简单工厂模式的工厂类解耦为抽象工厂+具体工厂,他们的抽象产品角色和具体产品角色仍然是相同的.
//抽象产品角色
package com.sunsplanter.factory;public abstract class Weapon {/*** 所有武器都有攻击行为*/public abstract void attack();
}
//具体产品角色tank/Fighter
package com.sunsplanter.factory;public class Tank extends Weapon{@Overridepublic void attack() {System.out.println("坦克开炮！");}
}```java
package com.sunsplanter.factory;public class Fighter extends Weapon{@Overridepublic void attack() {System.out.println("战斗机投下原子弹！");}
}
//抽象工厂角色(武器工厂接口)
package com.sunsplanter.factory;public interface WeaponFactory {Weapon get();
}
//具体工厂角色
package com.sunsplanter.factory;public class TankFactory implements WeaponFactory{@Overridepublic Weapon get() {return new Tank();}
}//具体工厂角色
package com.sunsplanter.factory;public class FighterFactory implements WeaponFactory{@Overridepublic Weapon get() {return new Fighter();}
}
package com.sunsplanter;public class Client {public static void main(String[] args) {TankFactory tankFactory = new TankFactory();//Weapon类型的gunTank tank = tankFactory.get();tank.attack();}
}如果想扩展一个新的产品，只要新增一个产品类，再新增一个该产品对应的工厂即可，例如新增：匕首
//新增一个具体产品角色
package com.sunsplanter;public class Dagger extends Weapon{@Overridepublic void attack() {System.out.println("砍丫的！");}
}
//新增一个具体工厂角色
package com.sunsplanter;public class DaggerFactory implements WeaponFactory{@Overridepublic Weapon get() {return new Dagger();}
}
抽象工厂模式
在工厂方法模式上再次进化,允许存在多个产品系列/工厂系列.
