【设计模式】工厂模式 详解

概述：

工厂模式，顾名思义，就是 创建 目标对象 的 工厂
由 同一个工厂 所加工的 不同类对象，都有着 共同点，但也存在 一些不同的特点

工厂模式，一共分为 3种：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

---

那么，本人先来讲解下 简单工厂模式：

简单工厂 模式：

概述：

定义一个 具体的工厂类 负责 创建一些类的实例
简单工厂模式 是由 一个工厂对象 决定创建出 哪一种产品类 的 实例
简单工厂模式 是 工厂模式家族 中 最简单实用 的 模式

---

那么，本人来讲解下 简单工厂模式 的 优缺点：

优缺点：

优点：

使用简单

---

缺点：

• 违反 开闭原则：
  如果有 新的类型对象 增加，或者某些对象的 创建方式不同，
  就需要 不断地 修改工厂类，不利于 后期的维护

---

使用展示：

首先，本人来给出一个 动物类(抽象接口类)：

抽象接口类：

package edu.youzg.design.pattern.factory;

/**
 * 抽象接口类
 */
public abstract class Animal {
    abstract void cry();
}

---

接下来，本人给出 上述 抽象接口类 的 实现子类：

实现子类：

package edu.youzg.design.pattern.factory;

/**
 * 实现子类
 */
public class Dog extends Animal {

    public Dog() {
    }

    @Override
    public void cry() {
        System.out.println("汪~~");
    }

}

package edu.youzg.design.pattern.factory;

/**
 * 实现子类
 */
public class Cat extends Animal {

    public Cat() {
    }

    @Override
    public void cry() {
        System.out.println("喵~~");
    }

}

现在，本人来给出一个 工厂类：

简单工厂：

package edu.youzg.about_design_mode.core;

/**
 * 简单工厂
 */
public class SimpleAnimalFactory {

    private AnimalFactory() {
    }

    public static Animal createAnimal(String name){
        if("cat".equals(name)){
            return new Cat();
        }else if("dog".equals(name)){
            return new Dog();
        } else if ("tiger".equals(name)) {
            return new Tiger();
        } else {
            return null;
        }
    }
}

现在，本人来给出一个测试类：

测试类：

package edu.youzg.design.pattern.factory;

/**
 * @Author: Youzg
 * @CreateTime: 2021-05-10 15:31
 * @Description: 带你深究Java的本质！
 */
public class YouzgTest {

    public static void main(String[] args) {
        SimpleAnimalFactory.createAnimal("dog").cry();

        SimpleAnimalFactory.createAnimal("cat").cry();
    }

}

那么，本人来展示下运行结果：

---

工厂方法 模式：

概述：

定义了一个 创建对象 的 抽象方法，由 子类 决定 要实例化的类
工厂方法模式 将 对象的实例化 推迟到 子类

---

优点：

客户端不需要 负责对象的创建，从而明确了各个类的职责，
如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

---

缺点：

需要额外的编写代码，增加了工作量

现在，本人来给出一个例子来展示下这个设计模式：

使用展示：

首先，本人在上文所给类的基础上，再提供两个 Animal 实现类：

实现子类：

package edu.youzg.design.pattern.factory;

/**
 * @Author: Youzg
 * @CreateTime: 2021-05-10 16:12
 * @Description: 带你深究Java的本质！
 */
public class Frog extends Animal {
    @Override
    void cry() {
        System.out.println("呱~");
    }
}

package edu.youzg.design.pattern.factory;

/**
 * @Author: Youzg
 * @CreateTime: 2021-05-10 16:13
 * @Description: 带你深究Java的本质！
 */
public class Elephant extends Animal{

    @Override
    void cry() {
        System.out.println("牟~");
    }

}

---

接下来，本人来给出一个 初始工厂类：

初始工厂类：

package edu.youzg.design.pattern.factory;

/**
 * 初始工厂类
 */
public abstract class MethodAnimalFactory {

    public abstract Animal createAnimal(String name);

}

---

接下来，本人再来给出 初始工厂类 的 实现工厂类：

子工厂类：

package edu.youzg.design.pattern.factory;

/**
 * 实现工厂类1
 */
public class MammalsFactory extends MethodAnimalFactory {

    @Override
    public Animal createAnimal(String name) {
        if ("cat".equals(name)) {
            return new Cat();
        } else if ("dog".equals(name)) {
            return new Dog();
        } else {
            return null;
        }
    }

}

package edu.youzg.design.pattern.factory;

/**
 * 实现工厂类2
 */
public class AmphibiansFactory extends MethodAnimalFactory {

    @Override
    public Animal createAnimal(String name) {
        if ("frog".equals(name)) {
            return new Frog();
        } else if ("elephant".equals(name)) {
            return new Elephant();
        } else {
            return null;
        }
    }

}

---

接下来，本人再来给出 测试类：

测试类：

package edu.youzg.design.pattern.factory;

/**
 * @Author: Youzg
 * @CreateTime: 2021-05-10 15:31
 * @Description: 带你深究Java的本质！
 */
public class YouzgTest {

    public static void main(String[] args) {
        MethodAnimalFactory methodAnimalFactory = null;

        methodAnimalFactory = new MammalsFactory();
        methodAnimalFactory.createAnimal("dog").cry();

        methodAnimalFactory = new AmphibiansFactory();
        methodAnimalFactory.createAnimal("frog").cry();
    }

}

---

现在，本人来展示下 运行结果：

---

抽象工厂 模式：

使用展示：

本人在上面的例子的基础上，先给出一个 抽象工厂接口：

抽象工厂接口：

package edu.youzg.design.pattern.factory;

/**
 * 抽象工厂接口
 */
public interface AbstractAnimalFactory {

    Animal createAnimal();

}

接下来，本人再来给出 2个 动物子工厂类：

子工厂类：

package edu.youzg.design.pattern.factory;

/**
 * 子工厂1
 */
public class DogFactory implements AbstractAnimalFactory{

    @Override
    public Animal createAnimal() {
        return new Dog();
    }

}

package edu.youzg.design.pattern.factory;

/**
 * 子工厂2
 */
public class CatFactory implements AbstractAnimalFactory{

    @Override
    public Animal createAnimal() {
        return new Cat();
    }

}

最后，本人给出一个测试类：

测试类：

package edu.youzg.design.pattern.factory;

/**
 * @Author: Youzg
 * @CreateTime: 2021-05-10 15:31
 * @Description: 带你深究Java的本质！
 */
public class YouzgTest {

    public static void main(String[] args) {
        Animal dog = new DogFactory().createAnimal();
        dog.cry();
        Animal cat = new CatFactory().createAnimal();
        cat.cry();
    }

}

现在，本人来展示下运行结果：

---

看到这里，相信同学们对于 每一种工厂模式，都有了一定的理解

但是，相信很多同学和本人初学时一样，对于 工厂方法模式 和 抽象工厂模式 的理解，十分混淆！

那么，在文末，本人来讲解下 工厂方法模式 和 抽象工厂模式 的 区别：

工厂方法模式 与 抽象工厂模式：

• 工厂方法模式
  只是 在 子工厂 中，实现了 部分逻辑
  因此，使用的是 抽象类 作为 原始工厂
• 抽象工厂模式
  在 子工厂 中，实现了 全部逻辑
  因此，使用的是 接口 作为 原始工厂

---

那么，至此，工厂模式 就讲解完毕了！