工厂模式

简单工厂模式

简单工厂模式属于创建型模式，但不属于 23 种设计模式之一

定义：定义一个工厂类，它可以根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类

在简单工厂模式中用于被创建实例的方法通常为静态 (static) 方法，因此简单工厂模式又被称为静态工厂方法 (Static Factory Method)

需要什么产品就传入产品对应的参数，就可以获取所需要的产品对象，而无需知道其实现过程

例如：有一家饺子店，当客户需要某种饺子时，饺子店生成对应的饺子给客户。这里就可以把饺子店看成工厂 (Factory) ，饺子看成产品 (Product) ，饺子的名称看成参数，饺子店根据不同的参数返回不同的饺子

比如：客户想要韭菜饺子，这里韭菜就是参数，饺子店会根据参数韭菜返回韭菜饺子 (饺子店有韭菜饺子的前提下)

三类角色：

1. 工厂 (核心)

​ 负责实现创建所有产品的内部逻辑，工厂类可以被外界直接调用，创建所需对象

1. 抽象产品

​ 工厂类所创建的所有对象的父类，封装了产品对象的公共方法，所有的具体产品为其子类对象

1. 具体产品

​ 简单工厂模式的创建目标，所有被创建的对象都是某个具体类的实例

例子

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();
    }
}