设计模式之创建型模式（工厂模式）

简单工厂模式 – 将实例的生成交给子类

基本介绍

1. 简单工厂模式是属于创建型模式，是工厂模式的一种。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式
2. 简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为(代码)
3. 在软件开发中，当我们会用到大量的创建某种、某类或者某批对象时，就会使用到工厂模式.

简单工厂中的登场角色

• Product：产品， 它是工厂类所创建的所有对象的父类，封装了各种产品对象的公有方法，它的引入将提高系统的灵活性，使得在工厂类中只需定义一个通用的工厂方法，因为所有创建的具体产品对象都是其子类对象。（在实例程序中，Operation扮演此角色）
• ConcreteProduct：具体的产品， 它是简单工厂模式的创建目标，所有被创建的对象都充当这个角色的某个具体类的实例。它要实现抽象产品中声明的抽象方法（在实例程序中，Add类扮演此角色）
• Factory：工厂类， 简单工厂模式的核心部分，负责实现创建所有产品的内部逻辑；工厂类可以被外界直接调用，创建所需对象。（在实例程序中，Factory类扮演此角色）

//产品
public interface Operation {
    public double getResult(double a, double b);
}

//具体的产品
public class Add implements Operation{

    @Override
    public double getResult(double a, double b) {
        return a + b;
    }
}

//工厂类
public class Factory {

    public static Operation getOperation(String s){
        Operation operation = null;
        switch (s){
            case "+":
                operation = new Add();
                break;
            case "-":
                operation = new Sub();
                break;
            case "*":
                operation = new Mul();
                break;
            case "/":
                operation = new Div();
            default:
                break;
        }
        return operation;
    }
}

public static void main(String[] args) {
	//工厂类类封装实例化对象的具体行为，屏蔽产品的具体实现，调用者只关心产品的接口。
	//一个工厂对象决定创建出哪一种产品类
	Operation add = Factory.createOperation("+");
	System.out.println(add.getResule(1, 2));
}

当我们想实现减法时，只需将调用参数改为”-“即可，不用关心其具体的实现。

Operation sub = Factory.createOperation("-");

简单工厂模式存在的问题

如果我们需增加运算方式，比如增加开方运算，除了定义一个类实现Operation接口极其逻辑运算，还需修改switch case中的代码，增加开方运算的判断。这显然违反了开闭原则（对扩展开放，对修改关闭）。
简单工厂所能创建的类，都是实现考虑好的，如果增加新的类，则需修改工厂类。

工厂方法模式
基本介绍
定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方
法模式将对象的实例化交给子类。

framework包(框架)

1. Product：表示”产品“的类，在该类中仅声明use抽象方法，use方法的实现交给了Product类的子类负责。（在实例程序中，
   Product类扮演此角色）
2. Creator(创建者)：声明了用于”用于生成产品“的createProduct抽象方法和用于”注册产品“的registerProduct抽象方法，他们的具体处理都交给子类负责。（在实例程序中，Factory类扮演此角色）

idcard包（实际的加工处理）

1. ConcreteProduct：属于具体加工的一方，它决定了具体的产品。（在实例程序中，IDCard类扮演此角色）
2. ConcreteCreator（具体的创建者）：工厂的实现覆盖 Factory 定义的工厂方法，返回具体的 Product
   实例。（在实例程序中，IDCardfactory类扮演此角色）

//产品
public abstract class Product {
    public abstract void use();
}

//工厂
public abstract class Factory {
    public final Product create(String owner){
        Product p = createProduct(owner);
        registerProduct(p);
        return p;
    }
    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}

//具体的产品
public class IDCard extends Product {
    private String owner;
    private Integer id;

    IDCard(String owner, Integer id) {
        this.owner = owner;
        this.id = id;
    }
    @Override
    public void use() {
        System.out.println("使用" + owner + "id：" +  id);
    }
    public String getOwner(){
        return owner;
    }

    public Integer getId() {
        return id;
    }
}

//具体的创建者（工厂）
public class IDCardFactory extends Factory {
    private static Integer ID = 1;
    private Map<String, Integer> maps = new HashMap<>();
    @Override
    protected Product createProduct(String owner) {
        return new IDCard(owner, ID ++);
    }

    @Override
    protected void registerProduct(Product product) {
        IDCard idCard = (IDCard) product;
        maps.put(idCard.getOwner(), idCard.getId());
    }

    public Map<String, Integer> getMaps() {
        return maps;
    }
}

工厂方法模式在设计上完全完全符合“开闭原则”。当我们用相同的框架创建出其他的产品和工厂。例如创建表示电视机的类和表示电视机工厂的类，我们只需引入frame包，实现Product和factory即可。
请注意我们没有修改，也没有必要修改framework包内的内容，就可以创建出其他的产品和工厂
在framework包中我们并没有引入idcard包内的内容，在Product和factory中没有出现IDCard和IDCardFactory等具体类的名字，我们称作framework包不依赖idcard包。

工厂方法模式也有缺点：每次增加产品时，都需要增加一个具体类和具体的实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。