设计模式 | 工厂模式

1 介绍

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式， 工厂模式有几条概念如下：

1. 任何可以产生对象的方法或者类，都称之为工厂；
2. 单例也是一种工厂；

其中工厂模式又分为如下几种：
3. 简单工厂
4. 静态工厂
5. 工厂方法
6. 抽象工厂
7. Spring IOC

·不过本文只介绍比较常用的，简单工厂、抽象工厂以及ioc·

---

为什么有new之后，还需要工厂？

1. 灵活控制生产过程；
2. 添加权限、修饰、日志等前置后置操作；
3. …

---

2 简单工厂实现

场景：

要实现一个载具的工厂，其中载具包括：车、飞机、魔法扫把等

代码结构如下：

---

2.1 定义po对象

定义一个通用属性接口：Movable.java

package com.chen.design_pattern.factory.move;

// 可移动的
public interface Movable {
    void go();
}

1
2
3
4
5
6
7

---

三个实现类对象：

魔法扫把 Broom.java

package com.chen.design_pattern.factory.move;

public class Broom implements Movable {
    @Override
    public void go() {
        System.out.println("魔法扫把布灵布灵....");
    }
}
1
2
3
4
5
6
7
8

汽车 Car.java

package com.chen.design_pattern.factory.move;

public class Car implements Movable {
    @Override
    public void go() {
        System.out.println("汽车滴滴滴滴...");
    }
}
1
2
3
4
5
6
7
8

飞机 Plane.java

package com.chen.design_pattern.factory.move;

public class Plane implements Movable {
    @Override
    public void go() {
        System.out.println("飞机呼呼呼呼....");
    }
}
1
2
3
4
5
6
7
8

---

2.2 定义工厂

VehicleFactory.java

package com.chen.design_pattern.factory.factory;

import com.chen.design_pattern.factory.move.Broom;
import com.chen.design_pattern.factory.move.Car;
import com.chen.design_pattern.factory.move.Plane;

public class VehicleFactory {

    public Car createCar() {
        // 可以添加一些前置操作，比如日志、权限、缓存等等
        return new Car();
    }

    public Plane createPlane() {
        // 可以添加一些前置操作，比如日志、权限、缓存等等
        return new Plane();
    }

    public Broom createBroom() {
        // 可以添加一些前置操作，比如日志、权限、缓存等等
        return new Broom();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

2.3 Main方法

Main.java

public class Main {
    public static void main(String[] args) {
        VehicleFactory factory = new VehicleFactory();
        Car car = factory.createCar();
        Broom broom = factory.createBroom();
        Plane plane = factory.createPlane();

        car.go();
        broom.go();
        plane.go();
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13

打印结果如下：

---

3. 抽象工厂

简介：

• 模式属于创建型模式，它提供了一种创建对象的最佳方式。
• 抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。
• 在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

---

场景：

假设实现一个作战人物工厂：两个世界（魔法世界、现实世界）中的作战人物所运用的道具不相同：

1. 现实世界的作战单元是士兵，使用枪支，坐骑是汽车，吃面包
2. 魔法世界作战单元是魔法人，使用魔棒共计，坐骑是魔法扫帚，食物是魔法蘑菇

包结构如下：

---

3.1 定义‘食物’抽象类

Food.java

public abstract class Food {
   public abstract void eat();
}
1
2
3

---

实现食物抽象类
面包 Bread.java

public class Bread extends Food{
    @Override
    public void eat() {
        System.out.println("吃面包");
    }
}
1
2
3
4
5
6

魔法蘑菇 MushRoom.java

public class MushRoom extends Food{
    @Override
    public void eat() {
        System.out.println("吃魔法蘑菇");
    }
}
1
2
3
4
5
6

---

3.2 定义‘载具’抽象类

Vehicle.java

public abstract class Vehicle {
    public abstract void go();
}
1
2
3

---

实现载具抽象类
汽车 Car.java

public class Car extends Vehicle{
    @Override
    public void go() {
        System.out.println("开小汽车跑");
    }
}
1
2
3
4
5
6

魔法扫把 Broom.java

public class Broom extends Vehicle{
    @Override
    public void go() {
        System.out.println("骑着扫把飞");
    }
}
1
2
3
4
5
6

---

3.2 定义‘武器’抽象类

Weapon.java

public abstract class Weapon {
    public abstract void attack();
}
1
2
3

---

实现武器抽象类
枪支 AK47.java

public class AK47 extends Weapon {
    @Override
    public void attack() {
        System.out.println("AK47物理超度");
    }
}
1
2
3
4
5
6

魔法棒 MagicStick.java

public class MagicStick extends Weapon {
    @Override
    public void attack() {
        System.out.println("魔法棒施法攻击");
    }
}
1
2
3
4
5
6

---

3.3 定义工厂

定义人物角色抽象工厂
CharacterAbstractFactor.java

public abstract class CharacterAbstractFactory {
    public abstract Food createFood();
    public abstract Vehicle createVehicle();
    public abstract Weapon createWeapon();
}
1
2
3
4
5

---

实现士兵工厂抽象类
枪支 SoldierFactory.java

// 士兵工厂
public class SoldierFactory extends CharacterAbstractFactory {
    @Override
    public Food createFood() {
        return new Bread();
    }

    @Override
    public Vehicle createVehicle() {
        return new Car();
    }

    @Override
    public Weapon createWeapon() {
        return new AK47();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

实现魔法人物工厂 MagicFigureFactory.java

// 魔法人物工厂
public class MagicFigureFactory extends CharacterAbstractFactory {
    @Override
    public Food createFood() {
        return new MushRoom();
    }

    @Override
    public Vehicle createVehicle() {
        return new Broom();
    }

    @Override
    public Weapon createWeapon() {
        return new MagicStick();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

---

3.4 Main方法

Main.java

public class Main {
    public static void main(String[] args) {
        CharacterAbstractFactory magicFigureFactory = new MagicFigureFactory();
        CharacterAbstractFactory soldierFactory = new SoldierFactory();

        Food magicFood = magicFigureFactory.createFood();
        magicFood.eat();

        Food soldierFood = soldierFactory.createFood();
        soldierFood.eat();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

执行结果如下：