设计模式02——工厂模式

---

定义

`创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

---

创建方式

1.简单工厂模式

1.1 定义

简单工厂模式是通过使用静态方法接收不同的参数来返回不同的实例对象。

实现方式是定义一个工厂类，根据传入的参数不同返回不同的实例，被创建的实例具有共
同的父类或接口。

• 抽象产品 ：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品 ：实现或者继承抽象产品的子类。
• 具体工厂 ：提供了创建产品的方法，调用者通过该方法来获取产品。

1.2 代码实现

产品接口及实现

// 抽象产品接口
public interface Product {
	// 产品创建方法
    void create();
}

// 产品1具体实现
public class Product01 implements Product{
    @Override
    public void create() {
        System.out.println("create product 01");
    }
}

// 产品2具体实现
public class Product02 implements Product{
    @Override
    public void create() {
        System.out.println("create product 02");
    }
}

// 产品3具体实现
public class Product03 implements Product{
    @Override
    public void create() {
        System.out.println("create product 03");
    }
}

产品工厂及测试：

// 产品工厂
public class ProductFactory {

    public static Product getProduct(Integer type) {
        if (type == 1) {
            return new Product01();
        } else if (type == 2) {
            return new Product02();
        } else if (type == 3) {
            return new Product03();
        } else {
            throw new RuntimeException("类型匹配异常");
        }
    }

	// 测试方法
    public static void main(String[] args) {
        Product product01 = getProduct(1);
        product01.create();

        Product product02 = getProduct(2);
        product02.create();

        Product product03 = getProduct(3);
        product03.create();
    }
}

---

2.工厂方法模式

2.1 定义

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。
工厂方法使一个产品类的实例化延迟到其工厂的子类。

• 抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法
  来创建产品。
• 具体工厂：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
• 抽象产品：定义了产品的规范，描述了产品的主要特性和功能。
• 具体产品：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具
  体工厂之间一一对应。

其本质就是在简单工厂模式的基础上，区分不同产品的工厂，对其进行抽象和具体实现。

2.2 代码实现

产品接口及实现

// 抽象产品接口
public interface Product {
	// 产品创建方法
    void create();
}

// 产品1具体实现
public class Product01 implements Product{
    @Override
    public void create() {
        System.out.println("create product 01");
    }
}

// 产品2具体实现
public class Product02 implements Product{
    @Override
    public void create() {
        System.out.println("create product 02");
    }
}

// 产品3具体实现
public class Product03 implements Product{
    @Override
    public void create() {
        System.out.println("create product 03");
    }
}

工厂和工厂具体实现

// 抽象工厂
public interface ProductFactory{
    Product getInstance();
}

// 具体工厂1
public class Product01Factory implements ProductFactory{
    @Override
    public Product getInstance() {
        System.out.println("product 01 factory create product");
        return new Product01();
    }
}

// 具体工厂2
public class Product02Factory implements ProductFactory{
    @Override
    public Product getInstance() {
        System.out.println("product 02 factory create product");
        return new Product02();
    }
}

// 具体工厂3
public class Product03Factory implements ProductFactory {
    @Override
    public Product getInstance() {
        System.out.println("product 03 factory create product");
        return new Product03();
    }
}

测试：

public class ProductFactoryMap {
    
    // 工厂对象可以不用重复创建（只有产品对象需要需要重复创建），所以可以配合单例模式使用
    private static final Map<Integer,ProductFactory> productFactories = new HashMap<>();

    static {
        productFactories.put(1,new Product01Factory());
        productFactories.put(2,new Product02Factory());
        productFactories.put(3,new Product03Factory());
    }

    public static ProductFactory getFactory(Integer type){
        return productFactories.get(type);
    }

    public static void main(String[] args) {
        ProductFactory product01Factory = getFactory(1);
        Product product01 = product01Factory.getInstance();
        product01.create();

        ProductFactory product02Factory = getFactory(2);
        Product product02 = product02Factory.getInstance();
        product02.create();

        ProductFactory product03Factory = getFactory(3);
        Product product03 = product03Factory.getInstance();
        product03.create();
    }
}

---

3.总结

工厂模式主要用来创建相关类型的对象（继承同一父类或同一接口），根据指定的参数来决定创建哪种类型的对象。