简单工厂模式（Factory Method）

定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类，使得一个类的实例化可以延迟到子类实现。

本质

选择实现。

简单工厂的重点在于选择，实现是已经做好了的，目的在于为客户端来选择相应的实现，从而使得客户端和实现之间解耦，这样一来，实现发生了变化，就不用变更客户端了。

登场角色

• Product（产品）

  产品抽象类，定义了产品特性，即客户所需要的功能接口。

• Creator（创建者）

  工厂抽象类，定义产品的生成流程，

• ConcreteProduct（具体的产品）

  决定具体的产品，因为它实现了产品的特性，可能会有多个。

• ConcreteCreator（具体的创建者）

  负责生成具体的产品，因为它实现了产品的生成流程。

示例代码

/**
 * 产品的抽象类，定义了产品的特性
 */
public abstract class Product {
    public abstract void use();
}


/**
 * 生成产品的抽象类，定义了生成产品的步骤
 */
public abstract class Factory {
    public final Product create(String owner){
        Product product = createProduct(owner);
        resisterProduct(product);
        return product;
    }
    protected abstract Product createProduct(String owner);
    protected abstract void resisterProduct(Product product);
}


/**
 * 具体的产品实现类
 */
public class IDCard extends Product{
    private String owner;
    IDCard(String owner) {
        System.out.println("制作" + owner + "的ID卡");
        this.owner = owner;
    }

    @Override
    public void use() {
        System.out.println("使用了" + owner + "的ID卡");
    }

    public String getOwner() {
        return owner;
    }
}


/**
 * 生成产品的工厂，实现了产品的生产过程
 */
public class IDCardFactory extends Factory{
    private List<String> owners = new ArrayList();
    @Override
    protected Product createProduct(String owner) {
        return new IDCard(owner);
    }

    public List<String> getOwners() {
        return owners;
    }

    @Override
    protected void resisterProduct(Product product) {
        owners.add(((IDCard)product).getOwner());
    }
}


/**
 * 测试
 */
public class RunFactory {
    public static void main(String args[]){
        Factory factory = new IDCardFactory();
        Product idCard1 = factory.create("小明1");
        Product idCard2 = factory.create("小明2");
        Product idCard3 = factory.create("小明3");

        idCard1.use();
        idCard2.use();
        idCard3.use();
    }
}

运行结果

制作小明1的ID卡
制作小明2的ID卡
制作小明3的ID卡
使用了小明1的ID卡
使用了小明2的ID卡
使用了小明3的ID卡

功能

用来创建一个具体的类实例。

优点

• 封装，封装了对象的实现过程，使外部的调用能够面向接口编程。
• 解耦，因为封装了对象的实现过程，使得外部仅通过接口调用就可以得到对象的引用， 从而实现了对象的创建和使用的解耦。

缺点

• 增加了外部获取对象的复杂度，因为创建对象所需要的参数，需要外部提供，这样就需要外部能够理解每一个参数的含义，增加了使用的难度。

何时使用

• 想要完全封装隔离具体实现，让外部只能通过接口取得对象，那么可以选用简单工厂模式，让客户端通过工厂提供的接口来取得对象，而不用关心对象的具体实现。
• 如果想把对外创建对象的职责集中管理和控制，可以选用简单工厂，一个简单工厂模式可以创建很多、不相关的对象。