本文主要是介绍『Java』设计模式（Design pattern）之工厂模式（Factory Pattern），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 前言
• 简单工厂模式（Simple Factory Pattern）
• • 抽象产品
  • 具体产品
  • 具体工厂
  • main方法demo
• 工厂方法模式（Factory Method Pattern）
• • 抽象工厂
  • 具体工厂
  • main方法demo
• 抽象工厂模式（Abstract Factory Pattern）
• • 变化
  • • 新增抽象产品
    • 新增具体产品
    • 改进抽象工厂
    • 改进具体工厂
    • main方法demo
  • 如何增加一个新的工厂
  • 如何增加一个新的产品
• 完

前言

设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。工厂模式属于创建型模式。工厂顾名思义就是创建产品，根据产品是具体产品还是具体工厂可分为简单工厂模式和工厂方法模式，根据工厂的抽象程度可分为工厂方法模式和抽象工厂模式。

工厂模式的本质就是对获取对象过程的抽象。

工厂模式（factory Method）的本质是什么？为什么引入工厂模式？
设计模式之工厂模式（factory pattern）

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

• 优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。3、屏蔽产品的具体实现，调用者只关心产品的接口。
• 缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

工厂模式 | 菜鸟教程

简单工厂模式（Simple Factory Pattern）

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，由一个工厂对象决定创建出哪一种产品类的实例。也就是使用一个工厂类来创建任何产品类实例，通过一个产品的抽象类来实现不同产品。缺点在于如果需要新增产品类，就必须修改工厂类

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类（这些产品类继承自一个父类或接口）的实例。

简单工厂模式_百度百科

下面以汽车生产为例子写一个demo

抽象产品

产品抽象类规定了产品的实现标准

package factory;

public interface Car {
    void make();
    void drive();
}

具体产品

对于每种产品的具体实现

package factory;

public class BenzCar implements Car {
    public BenzCar() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("Make Benz car");
    }

    @Override
    public void drive() {
        System.out.println("Benz car is running");
    }
}

package factory;

public class BMWCar implements Car {
    public BMWCar() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("Make BMW car");
    }

    @Override
    public void drive() {
        System.out.println("BMW car is running");
    }
}

具体工厂

简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。

如果添加新产品，添加即可

package factory.simpleFactory;

import factory.BMWCar;
import factory.BenzCar;
import factory.Car;

public class CarFactory {
    public Car makeCar(String brand){
        if(brand.equalsIgnoreCase("Benz")){
            return new BenzCar();
        }else if(brand.equalsIgnoreCase("BMW")){
            return new BMWCar();
        }else{
            return null;
        }
    }
}

main方法demo

新建工厂，生产产品即可

package factory.simpleFactory;

import factory.BenzCar;
import factory.Car;

public class Main {
    public static void main(String[] args) throws Exception {
        CarFactory carFactory = new CarFactory();
        Car car1 = carFactory.makeCar("BMW");
        BenzCar car2 = (BenzCar) carFactory.makeCar("Benz");
        car1.drive();
        car2.drive();
    }
}

Make BMW car
Make Benz car
BMW car is running
Benz car is running

工厂方法模式（Factory Method Pattern）

工厂方法模式将生成具体产品的任务分发给具体的产品工厂，核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

也就是说一个工厂只负责生产一种产品，一种产品唯一来自一个工厂

工厂方法模式对简单工厂模式进行了抽象。有一个抽象的Factory类（可以是抽象类和接口），这个类将不再负责具体的产品生产，而是只制定一些规范，具体的生产工作由其子类去完成。在这个模式中，工厂类和产品类往往可以依次对应。即一个抽象工厂对应一个抽象产品，一个具体工厂对应一个具体产品，这个具体的工厂就负责生产对应的产品。

工厂方法模式_百度百科

抽象工厂

定义工厂的规范

package factory.factoryMethod;

import factory.Car;

public abstract class CarFactory {
    abstract public Car makeCar();
}

具体工厂

按照产品类型，一家工厂只生产一种产品来实现工厂

package factory.factoryMethod;

import factory.BenzCar;
import factory.Car;

public class BenzCarFactory extends CarFactory{
    @Override
    public Car makeCar() {
        return new BenzCar();
    }
}

package factory.factoryMethod;

import factory.BMWCar;
import factory.Car;

public class BMWCarFactory extends CarFactory{
    @Override
    public Car makeCar() {
        return new BMWCar();
    }
}

main方法demo

新建不同工厂以生产不同产品

package factory.factoryMethod;

import factory.BMWCar;
import factory.Car;

public class Main {
    public static void main(String[] args) {
        CarFactory carFactory1 = new BenzCarFactory();
        BMWCarFactory carFactory2 = new BMWCarFactory();
        Car car1 = carFactory1.makeCar();
        BMWCar car2 = (BMWCar) carFactory2.makeCar();
        car1.drive();
        car2.drive();
    }
}

抽象工厂模式（Abstract Factory Pattern）

简单工厂模式实现了一个工厂生产不同品牌的同类产品、工厂方法模式实现了不同品牌的工厂分别生产各自的单一同类产品，抽象工厂模式实现了不同品牌的工厂分别生产各自的多种同类产品。工厂模式中的每一个形态都是针对一定问题的解决方案，工厂方法针对的是多个产品系列结构；而抽象工厂模式针对的是多个产品族结构，一个产品族内有多个产品系列。

变化

是工厂方法模式的一种衍生

抽象工厂模式和工厂模式的区别？
抽象工厂模式_百度百科

也就是说某品牌工厂不止生产小汽车了，现在还生产拖拉机

新增抽象产品

新增拖拉机产品

package factory;

public interface Tractor {
    void make();
    void drive();
}

新增具体产品

新增两个品牌的拖拉机

package factory;

public class BenzTractor implements Tractor {
    public BenzTractor() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("Make Benz tractor");
    }

    @Override
    public void drive() {
        System.out.println("Benz tractor is running");
    }
}

package factory;

public class BMWTractor implements Tractor {
    public BMWTractor() {
        this.make();
    }

    @Override
    public void make() {
        System.out.println("Make BMW tractor");
    }

    @Override
    public void drive() {
        System.out.println("BMW tractor is running");
    }
}

改进抽象工厂

添加生产接口

package factory.abstractFactory;

import factory.Car;
import factory.Tractor;

public abstract class Factory {
    abstract public Car makeCar();
    abstract public Tractor makeTractor();
}

改进具体工厂

实现生产接口

package factory.abstractFactory;

import factory.BenzCar;
import factory.BenzTractor;
import factory.Car;
import factory.Tractor;

public class BenzFactory extends Factory{
    @Override
    public Car makeCar() {
        return new BenzCar();
    }

    @Override
    public Tractor makeTractor() {
        return new BenzTractor();
    }
}

package factory.abstractFactory;

import factory.BMWCar;
import factory.BMWTractor;
import factory.Car;
import factory.Tractor;

public class BMWFactory extends Factory{
    @Override
    public Car makeCar() {
        return new BMWCar();
    }

    @Override
    public Tractor makeTractor() {
        return new BMWTractor();
    }
}

main方法demo

package factory.abstractFactory;

import factory.Car;
import factory.Tractor;

public class Main {
    public static void main(String[] args) {
        Factory factory1 = new BenzFactory();
        Factory factory2 = new BMWFactory();

        Car car1 = factory1.makeCar();
        Tractor tractor1 = factory2.makeTractor();

        car1.drive();
        tractor1.drive();
    }
}

Make Benz car
Make BMW tractor
Benz car is running
BMW tractor is running

如何增加一个新的工厂

以新增奥迪工厂为例：

1. 增加奥迪工厂、继承自抽象工厂类
2. 增加奥迪车、继承自车类；增加奥迪拖拉机、继承自拖拉机类

如何增加一个新的产品

以上面新增的拖拉机类为例：

1. 增加拖拉机类
2. 增加各自工厂的拖拉机、继承自拖拉机类
3. 在抽象工厂增加生产拖拉机的接口
4. 在各自具体工厂类实现生产拖拉机的接口

完

欢迎在评论区留言，欢迎关注我的CSDN @Ho1aAs

这篇关于『Java』设计模式（Design pattern）之工厂模式（Factory Pattern）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！