本文最后更新于 477 天前，其中的信息可能已经有所发展或是发生改变。
简单工厂模式
简单工厂模式属于创建型模式，但不属于 23 种设计模式之一
定义：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类
在简单工厂模式中用于被创建实例的方法通常为静态 (static) 方法，因此简单工厂模式又被称为静态工厂方法 (Static Factory Method)
需要什么产品就传入产品对应的参数，就可以获取所需要的产品对象，而无需知道其实现过程
例如：有一家饺子店，当客户需要某种饺子时，饺子店生成对应的饺子给客户。这里就可以把饺子店看成工厂 (Factory) ，饺子看成产品 (Product) ，饺子的名称看成参数，饺子店根据不同的参数返回不同的饺子
比如：客户想要韭菜饺子，这里韭菜就是参数，饺子店会根据参数韭菜返回韭菜饺子 (饺子店有韭菜饺子的前提下)
三类角色：
- 工厂 (核心)
负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象
- 抽象产品
工厂类所创建的所有对象的父类，封装了产品对象的公共方法，所有的具体产品为其子类对象
- 具体产品
简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例
例子
public class SimpleFactory{
public static void main(String[] args){
Product productA = Factory.createProduct("A");
productA.info();
// ...
}
}
abstract class Product{
public abstract void info();
}
class ProductA extends Product{
@Override
public void info(){
System.out.println("A");
}
}
class ProductB extends Product{
@Override
public void info(){
System.out.println("B");
}
}
class Factory{
public static Product creatProduct(String type){
Product p = null;
// 此处未考虑异常情况以及处理
switch(type){
case "A":
p = new ProductA();
break;
case "B":
p = new ProductB();
break;
default:
System.out.println("Please try again");
break;
}
return p;
}
}当增加产品时，将更改工厂，违反了 开发 – 封闭原则
工厂方法模式
Factory Method Pattern 类创建型模式
意图
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类
结构
其中：
- Product 定义工厂方法所创建的对象的接口
- ConcreteProduct 实现 Product 接口
- Creator 声明工厂方法，该方法返回一个 Product 类型的对象，Creator 也可以定义一个工厂方法的默认实现，它返回一个默认的 ConcreteProduct 对象，可以调用工厂方法以创建一个 Product 对象
- ConcreteCreator 重定义工厂方法以返回一个 ConcreteProduct 实例
适用性
Factory Method 模式适用于：
- 当一个类不知道它所必须创建的对象的类的时候
- 当一个类希望由它的子类来指定它所创建的对象的时候
- 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候
例子
/* 在上一个代码的基础上修改 */
public class FactoryMethod{
public static void main(String[] args){
Factory factoryA = new FactoryA();
//Product productA = Factory.createProduct("A");
Product productA = factoryA.createProduct();
productA.info();
// ...
}
}
// 抽象类改接口
// abstract class Product
interface class Product{
// public abstract void info();
public void info();
}
// 继承改实现
// class ProductA extends Product{
class ProductA implements Product{
@Override
public void info(){
System.out.println("A");
}
}
// 继承改实现
// class ProductB extends Product{
class ProductB implements Product{
@Override
public void info(){
System.out.println("B");
}
}
// 实类改接口
// class Factory
interface Factory{
public Product creatProduct();
}
// 增加接口实现
class FactoryA implements Factory{
@Override
public Product createProduct(){
return new ProductA();
}
}
class FactoryB implements Factory{
@Override
public Product createProduct(){
return new ProductB();
}
}抽象工厂模式
Abstract Factory Pattern 对象创建型模式
意图
提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们具体的类
结构
其中：
- AbstractFactory 声明一个创建抽象产品对象的操作接口
- ConcreteFactory 实现创建具体产品对象的操作
- AbstractProduct 为一类产品对象声明一个接口
- ConcreteProduct 定义一个将被相应的具体工厂创建的产品对象，实现 AbstractProduct 接口
- Client 仅使用由 AbstractFactory 和 AbstractProduct 类声明的接口
适用性
Abstract Factory 模式适用于：
- 一个系统要独立于它的产品的创建、组合和表示时
- 一个系统要由多个产品系列中的一个来配置时
- 当要强调一系列相关的产品对象的设计以便进行联合使用时
- 当提供一个产品类库，只想显示它们的接口而不是实现时
例子
public class AbstractFactory{
public static void main(String[] args){
Factory factory1 = new Factory1();
ProductA productA = factory1.createProductA();
productA.info();
/* ... */
}
}
interface class ProductA{
public void info();
}
class ProductA1 implements ProductA{
@Override
public void info(){
System.out.println("A1");
}
}
class ProductA2 implements ProductA{
@Override
public void info(){
System.out.println("A2");
}
}
interface class ProductB{
public void info();
}
class ProductB1 implements ProductB{
@Override
public void info(){
System.out.println("B1");
}
}
class ProductB2 implements ProductB{
@Override
public void info(){
System.out.println("B2");
}
}
interface Factory{
public ProductA creatProductA();
public ProductB creatProductB();
}
class Factory1 implements Factory{
@Override
public ProductA createProductA(){
return new ProductA1();
}
@Override
public ProductB createProductB(){
return new ProductB1();
}
}
class Factory2 implements Factory{
@Override
public ProductA createProductA(){
return new ProductA2();
}
@Override
public ProductB createProductB(){
return new ProductB2();
}
}