设计模式——工厂模式
工厂模式核心是封装对象的创建接口，将new对象的操作封装起来，方便创建使用、管理对象。
工厂模式的分类
- 简单工厂模式（Simple Factory）
- 工厂方法模式（Factory Method）
- 抽象工厂模式（Abstract Factory）
工厂模式适用于：
- 在编码时不能预见需要创建哪种类的实例。
- 系统不应依赖于产品类实例如何被创建、组合和表达的细节
简单工厂模式
简单工厂模式又称为静态工厂方法模式。简单工厂模式是由一个工厂类来控制产品类对象的创建，模式构成比较简单，适用于简单稳定、扩展少的模块。它由三部分角色类构成：
- 简单工厂类：它是本模块的核心，用于创建对应的产品对象，包含一定的逻辑处理。
- 抽象产品类：它一般是具体产品继承的父类或者实现的接口，一般由接口或者抽象类来实现，它定义了产品的特点。
- 具体产品类：具体需要创建的产品类对象的实例。
它们之间关系的UML图如下：
具体的演示实例：
首先我们创建抽象产品了Ball，并定义了两个具体的产品BasketBall和FootBall。
/**
* 定义一个球的实体
* @author Iflytek_dsw
*
*/
abstract class Ball {
/**
* 定义球的特性，都能玩
*/
public abstract void play();
}
class Basketball extends Ball{
private String name = "";
public Basketball(String name){
this.name = name;
}
@Override
public void play() {
System.out.println("拍打：" + name);
}
}
class Football extends Ball{
private String name = "";
public Football(String name){
this.name = name;
}
@Override
public void play() {
System.out.println("踢：" + name);
}
}
上面中创建了抽象产品类Ball，并定义方法play。同时每个具体产品类进行实现对应的方法。有了产品类，在定义一个简单工厂类：
/**
* 工厂类，用于封装创建对象的操作，对外进行封装，不被外部调用。
* 封装具体产品的创建对象。
* @author Iflytek_dsw
*
*/
public class BallFactory {
enum BallType{
BasketBall,
FootBall
}
public static Ball createBall(BallType ballType){
switch(ballType){
case BasketBall:
return new Basketball("篮球");
case FootBall:
return new Football("足球");
default:
return null;
}
}
}
这样，在简单工厂类中，我们封装了创建对象的静态方法。然后在客户端进行调用：
public class SimpleFactoryClient {
/**
* 通过简单工厂模式，我们可以根据我们的需求进行产品类的创建，直接进行使用，避免了客户端对产品的生产。
* 弊端是：如果我们新增一个品种，修改比较多。
* @param args
*/
public static void main(String[] args) {
//指定创建的类型
Ball basketBall = BallFactory.createBall(BallType.BasketBall);
basketBall.play();
Ball footBall = BallFactory.createBall(BallType.FootBall);
footBall.play();
}
}
简单工厂的优点/缺点：
- 优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。
- 缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则，当新增一个产品类是，需要改动工厂类，产品多，工厂类逻辑就过于复杂。
工厂方法模式
工厂方法模式，又称为多态性工厂模式，主要是利用面向对象的继承多态实现。在工厂方法模式中，核心的工厂类提取成为一个抽象工厂类，由对应产品的子类工厂负责创建对应的产品类对象。抽象工厂类只负责定义子类工厂需要实现的接口，不涉及具体产品类实例化的细节。工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。
工厂方法模式由四个角色类组成：
- 抽象工厂类：定义工厂类的方法，用来创建产品类
- 具体工厂类：用于创建对应的产品对象
- 抽象产品类：定义产品了公共的属性、方法
- 具体产品类：实现对应产品类的属性、方法
它们之间的UML关系图如下：
实现例子：
定义产品类对象：
/**
* 定义一个球的实体
* @author Iflytek_dsw
*
*/
abstract class Ball {
/**
* 定义球的特性，都能玩
*/
public abstract void play();
}
class Basketball extends Ball{
private String name = "";
public Basketball(String name){
this.name = name;
}
@Override
public void play() {
System.out.println("拍打：" + name);
}
}
class Football extends Ball{
private String name = "";
public Football(String name){
this.name = name;
}
@Override
public void play() {
System.out.println("踢：" + name);
}
}
定义工厂类：
/**
* 定义抽象工厂类，来定义所有工厂应该具备的职责，通性。
* @author Iflytek_dsw
*
*/
abstract class BallFacoty {
public abstract Ball createBall();
}
class BasketballFactory extends BallFacoty{
@Override
public Ball createBall() {
return new Basketball("篮球");
}
}
class FootballFactory extends BallFacoty{
@Override
public Ball createBall() {
return new Football("足球");
}
}
定义客户端：
public class MethodFactoryClient {
/**
* 工厂方法模式，根据需要，直接创建对象。方便扩展。无用改变Factory类代码，只需要新增。
* @param args
*/
public static void main(String[] args) {
BasketballFactory basketballFactory = new BasketballFactory();
Ball basketBall = basketballFactory.createBall();
basketBall.play();
FootballFactory footballFactory = new FootballFactory();
Ball footBall = footballFactory.createBall();
footBall.play();
}
}
工厂方法的优点/缺点：
优点：
子类提供挂钩。基类为工厂方法提供缺省实现，子类可以重写新的实现，也可以继承父类的实现。-- 加一层间接性，增加了灵活性
屏蔽产品类。产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
典型的解耦框架。高层模块只需要知道产品的抽象类，其他的实现类都不需要关心，符合迪米特法则，符合依赖倒置原则，符合里氏替换原则。
多态性：客户代码可以做到与特定应用无关，适用于任何实体类。
缺点：
需要Creator和相应的子类作为factory method的载体，如果应用模型确实需要creator和子类存在，则很好；否则的话，需要增加一个类层次，有点冗余。
抽象工厂模式
产品族： 位于不同产品等级结构中，功能相关联的产品组成的家族。抽象工厂模式是针对产品族进行使用，抽象工厂类的用途就是提供一个接口，创建多个产品族中的对象。比如，我们上面的例子中，篮球和足球就是产品层次结构。而篮球中又可以有大的和小的篮球种类，足球中也有大的和小的的足球种类，这里打篮球和大足球就属于产品族。
而且使用抽象工厂模式还要满足一下条件：
- 系统中有多个产品族，而系统一次只可能消费其中一族产品
- 同属于同一个产品族的产品以其使用。
来看看抽象工厂模式的各个角色：
- 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
- 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。在java中它由具体的类来实现。
- 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
- 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
来看具体的实例：
新建抽象产品类
abstract class Product {
public abstract void play();
}
abstract class ProductA extends Product{
public abstract void play();
}
abstract class ProductB extends Product{
public abstract void play();
}
class ProductABig extends ProductA{
@Override
public void play() {
System.out.print("ProductABig");
}
}
class ProductASmall extends ProductA{
@Override
public void play() {
System.out.print("ProductASmall");
}
}
class ProductBBig extends ProductB{
@Override
public void play() {
System.out.print("ProductBBig");
}
}
class ProductBSmall extends ProductB{
@Override
public void play() {
System.out.print("ProductBSmall");
}
}
抽象工厂类
abstract class Factory {
abstract ProductA createProductA();
abstract ProductB createProductB();
}
class FactoryBig extends Factory{
@Override
ProductA createProductA() {
return new ProductABig();
}
@Override
ProductB createProductB() {
return new ProductBBig();
}
}
class FactorySmall extends Factory{
@Override
ProductA createProductA() {
return new ProductASmall();
}
@Override
ProductB createProductB() {
return new ProductBSmall();
}
}
客户端
public static void main(String[] args) {
Factory factoryBig = new FactoryBig();
Product productABig = factoryBig.createProductA();
Product productBBig = factoryBig.createProductB();
productABig.play();
productBBig.play();
}
从抽象工厂特点来看，就是在工厂中不仅仅只生产一种对象，而是可以创建多种产品对象。
优点：
抽象工厂模式除了具有工厂方法模式的优点外，最主要的优点就是可以在类的内部对产品族进行约束。所谓的产品族，一般或多或少的都存在一定的关联，抽象工厂模式就可以在类内部对产品族的关联关系进行定义和描述，而不必专门引入一个新的类来进行管理。
缺点：
产品族的扩展将是一件十分费力的事情，假如产品族中需要增加一个新的产品，则几乎所有的工厂类都需要进行修改。所以使用抽象工厂模式时，对产品等级结构的划分是非常重要的。
适用场景：
当需要创建的对象是一系列相互关联或相互依赖的产品族时，便可以使用抽象工厂模式。通俗一点，就是一个继承体系中，如果存在着多个等级结构（即存在着多个抽象类），并且分属各个等级结构中的实现类之间存在着一定的关联或者约束，就可以使用抽象工厂模式。假如各个等级结构中的实现类之间不存在关联或约束，则使用多个独立的工厂来对产品进行创建，则更合适一点。
抽象工厂模式-与-工厂方法模式区别
首先来看看这两者的定义区别：
- 工厂模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类
- 抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类
区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。
再来看看工厂方法模式与抽象工厂模式对比：
| 工厂方法模式 | 抽象工厂模式 |
|---|---|
| 针对的是一个产品等级结构 | 针对的是面向多个产品等级结构 |
| 一个抽象产品类，可以派生出多个具体产品类 | 多个抽象产品类，每个抽象产品类可以派生出多个具体产品类 |
| 一个抽象工厂类，可以派生出多个具体工厂类 | 个抽象工厂类，可以派生出多个具体工厂类 |
| 每个具体工厂类只能创建一个具体产品类的实例 | 每个具体工厂类可以创建多个具体产品类的实例 |
总结
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。所以要多思考工厂模式的特点，设计模式这东西就是要多思考，理解，变换。
