前言

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

意图

提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

优缺点

优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。

实现

这里我将创建一个Car接口和Car接口的实现类以及Color接口和Color实现类,接着创建AbstractFactory接口和实现类CarFactory、ColorFactory,最后使用FactoryProducer用来创建获取工厂。

车接口和三种车类

1
2
3
4
5
6
/**
* 车接口
*/
public interface Car {
void createCar();
}
1
2
3
4
5
6
public class CarBenTian implements Car{
@Override
public void createCar() {
System.out.println("Create a BenTian.");
}
}
1
2
3
4
5
6
public class CarBMW implements Car{
@Override
public void createCar() {
System.out.println("Create a BMW.");
}
}
1
2
3
4
5
6
public class CarBYD implements Car{
@Override
public void createCar() {
System.out.println("Create a BYD.");
}
}

颜色接口和颜色类

1
2
3
public interface Color {
void fill();
}
1
2
3
4
5
6
public class ColorBlue implements Color{
@Override
public void fill() {
System.out.println("Fill Blue");
}
}
1
2
3
4
5
6
public class ColorGreen implements Color{
@Override
public void fill() {
System.out.println("Fill Green");
}
}
1
2
3
4
5
6
public class ColorRed implements Color{
@Override
public void fill() {
System.out.println("Fill Red");
}
}

创建抽象工厂接口

1
2
3
4
5
6
7
/**
* 抽象工厂
*/
public interface AbstractFactory {
Car getCar(String car);
Color getColor(String color);
}

车工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class CarFactory implements AbstractFactory {
@Override
public Car getCar(String car) {
if (car == null) {
return null;
} else if ("BMW".equals(car)) {
return new CarBMW();
} else if ("BYD".equals(car)) {
return new CarBYD();
} else if ("BenTian".equals(car)) {
return new CarBenTian();
}
return null;
}

@Override
public Color getColor(String color) {
return null;
}
}

颜色工厂

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class ColorFactory implements AbstractFactory {
@Override
public Car getCar(String car) {
return null;
}

@Override
public Color getColor(String color) {
if (color == null) {
return null;
} else if ("red".equals(color)) {
return new ColorRed();
} else if ("green".equals(color)) {
return new ColorGreen();
} else if ("blue".equals(color)) {
return new ColorBlue();
}
return null;
}
}

创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。
*/
public class FactoryProducer {
public static AbstractFactory getFactory(String choice) {
if (choice == null) {
return null;
} else if ("car".equals(choice)) {
return new CarFactory();
} else if ("color".equals(choice)) {
return new ColorFactory();
}
return null;
}
}

测试一波

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class TestAbstractFactory {
public static void main(String[] args) {
//获取到车工厂
AbstractFactory carFactory = FactoryProducer.getFactory("car");
//获取到颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("color");

/* 分别获取宝马、比亚迪、本田 车对象并调用createCar()方法 */
Car bmw = carFactory.getCar("BMW");
bmw.createCar();
Car byd = carFactory.getCar("BYD");
byd.createCar();
Car benTian = carFactory.getCar("BenTian");
benTian.createCar();

/* 分别获取红、绿、蓝 颜色对象并调用fill()方法 */
Color red=colorFactory.getColor("red");
red.fill();
Color green=colorFactory.getColor("green");
green.fill();
Color blue=colorFactory.getColor("blue");
blue.fill();
}
}

控制台输出

1
2
3
4
5
6
Create a BMW.
Create a BYD.
Create a BenTian.
Fill Red
Fill Green
Fill Blue

每天学一点,快乐每一天!