创建者模式 --- 工厂模式

一、学习参考

菜鸟教程：工厂模式
博客园：设计模式之工厂模式（factory pattern）

二、什么是工厂模式

创建者模式的一种、他提供了创建对象的一种最佳方式。工厂模式的用意是定义一个创建产品对象的工厂接口，将实际创建性工作推迟到子类中。工厂模式可分为简单工厂、工厂方法和抽象工厂模式

三、三大工厂

1. 简单工厂

简单工厂定义一个公共的父类或者接口、根据传入的参数不同创建不同实例。
需求：做一个动物简单工厂、根据传入的不同名创建对应的对象。

实现步骤：

1. 创建一个Animal公共接口

public interface Animal {
    void say();
}

2. 创建对应的子类、狗、猫、老虎

public class Dog implements Animal{

    @Override
    public void say() {
        System.out.println("汪汪。。");
    }

}

public class Cat implements Animal{

    @Override
    public void say() {
        System.out.println("喵喵。。");
    }
    
}

public class Tiger implements Animal{
    @Override
    public void say() {
        System.out.println("嗷嗷！！！");
    }
}

3. 创建一个创建动物的工厂

public class CreateAnimalFactory {

    public static Animal createAnimal(String type){
        Animal animal = null;
        if (type.equalsIgnoreCase("dog")){
            animal = new Dog();
        }else if (type.equalsIgnoreCase("cat")){
            animal = new Cat();
        }else if (type.equalsIgnoreCase("tiger")){
            animal = new Tiger();
        }
        return animal;
    }
}

4. 测试
   分别创建狗、猫、虎。

public class Test01 {

    @Test
    public void testSimpleFactory(){
        Animal animal = null;
        String[] arr = new String[]{"dog","cat","tiger"};
        for (String s : arr) {
            animal = CreateAnimalFactory.createAnimal(s);
            animal.say();
            System.out.println(animal.getClass().getName());
            System.out.println("========"+s+"==============");
        }
    }

}

测试结果

2.工厂方法

根简单工厂不同的是将工厂进行细分了、将具体的产品给具体的工厂。上面的动物是通过统一的AnimalFactory工厂创建的、而工厂方法就是细分创建狗的工厂给狗DogFactory，这样就不用通过指定类名创建了直接使用对应的工厂创建不同的实例。

工厂方法的实现思路是，定义一个用于创建对象的接口，让子类决定将哪一个类实例化。工厂方法模式让一个类的实例化延迟到其子类。

需求：做一个动物工厂方法、调用对应工厂创建对应的对象。

实现步骤：前两步和上面的简单工厂一样创建一份公共接口和对应具体实现类

1. 创建一个Animal公共接口

public interface Animal {
    void say();
}

2. 创建对应的子类、狗、猫、老虎

public class Dog implements Animal{

    @Override
    public void say() {
        System.out.println("汪汪。。");
    }

}

public class Cat implements Animal{

    @Override
    public void say() {
        System.out.println("喵喵。。");
    }
    
}

public class Tiger implements Animal{
    @Override
    public void say() {
        System.out.println("嗷嗷！！！");
    }
}

3. 创建一个工厂接口

public interface CreateAnimalFactory {

    Animal create();

}

4. 实现不同的工厂类

public class CreateDogFactory implements CreateAnimalFactory{
    @Override
    public Animal create() {
        return new Dog();
    }
}

public class CreateCatFactory implements CreateAnimalFactory{
    @Override
    public Animal create() {
        return new Cat();
    }
}

public class CreateTigerFactory implements CreateAnimalFactory{
    @Override
    public Animal create() {
        return new Tiger();
    }
}

5. 测试

@Test
    public void testFactoryMethod(){
        Animal animal = null;
        animal =  new CreateDogFactory().create();
        animal.say();
        System.out.println(animal.getClass().getName());
        animal =  new CreateCatFactory().create();
        animal.say();
        System.out.println(animal.getClass().getName());
        animal =  new CreateTigerFactory().create();
        animal.say();
        System.out.println(animal.getClass().getName());
    }

测试结果

工厂方法模式是简单工厂的仅一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂。

3.抽象工厂

同工厂方法、抽象工厂是对工厂方法的优化、他和工厂方法的区别就是抽象方法是实例化一组对象。

实现方法同前两个工厂的区别就是要有多个要实例化的对象、这里以生产电子产品为例、华为和小米是工厂、然后工厂具体的产品也就是对象实例有电脑和手机。

具体实现：

1. 创建手机和电脑实体接口和实现类

public interface PC {
    void openSay();
}
public interface Phone {
    void openSay();
}

=== 华为 ===
public class HWPC implements PC{
    @Override
    public void openSay() {
        System.out.println("欢迎使用华为电脑！！！");
    }
}

public class HWPhone implements Phone{
    @Override
    public void openSay() {
        System.out.println("欢迎使用华为手机！！！");
    }
}

== 小米 ==
public class XMPC implements PC{
    @Override
    public void openSay() {
        System.out.println("欢迎使用小米电脑！！！");
    }
}

public class XMPhone implements Phone{
    @Override
    public void openSay() {
        System.out.println("欢迎使用小米手机！！！");
    }
}

2. 创建抽象工厂
   相比简单工厂和工厂方法是创建多个实例

public interface AbstracFactory {
    
    // 创建电脑方法
    PC createPC();
    // 创建手机方法
    Phone createPhone();
    
}

3. 通过实现创建华为工厂和小米工厂
   同样相比前两种工厂也是要实现创建两种产品的方法

===  华为 ===
public class HWFactory implements AbstracFactory{
    @Override
    public PC createPC() {
        return new HWPC();
    }

    @Override
    public Phone createPhone() {
        return new HWPhone();
    }
}

=== 小米 ===
public class XMFactory implements AbstracFactory{
    @Override
    public PC createPC() {
        return new XMPC();
    }

    @Override
    public Phone createPhone() {
        return new XMPhone();
    }
}

4. 测试

@Test
    public void testAbstractFactory(){
        AbstracFactory factory = null;
        /* 华为 */
        System.out.println("华为");
        factory = new HWFactory();
        PC hwpc = factory.createPC();
        Phone hwphone = factory.createPhone();
        System.out.println(hwpc.getClass().getName());
        hwpc.openSay();
        System.out.println(hwphone.getClass().getName());
        hwphone.openSay();

        /* 小米 */
        System.out.println("小米");
        factory = new XMFactory();
        PC xmpc = factory.createPC();
        Phone xmphone = factory.createPhone();
        System.out.println(xmpc.getClass().getName());
        xmpc.openSay();
        System.out.println(xmphone.getClass().getName());
        xmphone.openSay();

    }

测试结果

四、总结

代码gittee地址：designStudy

上面介绍的三种工厂模式有各自的应用场景，实际应用时能解决问题满足需求即可，可灵活变通，无所谓高级与低级。

此外无论哪种模式，由于可能封装了大量对象和工厂创建，新加产品需要修改已定义好的工厂相关的类，因此对于产品和工厂的扩展不太友好，利弊需要权衡一下。