1.描述
抽象工厂模式、Abstract Factory Pattern。是创建型设计模式的一种,围绕一个超级工厂,来创建其他工厂。
主要解决:接口选择的问题。
使用场景:明确地知道什么情况下创建什么样的实例;为创建一组相关或相互依赖的对象提供一个接口,而且不需要指定它们的具体类。
举个栗子:暂时没想到
优点:基于工厂模式的升级版,多个工厂组合工作的时候可以用抽象工厂,是一个不错的方案。
缺点:产品族扩展困难。
源码在文末
2.代码实现
2.1.工具车产品定义
我们有一个工厂,可以生产工具车。工具车包括坦克、拖拉机、货车。在不同情况下,我们需要不同的工具车。
我们先定义一下我们的工具车
/**
* 工具车接口
*
* @author 编程还未
*/
public interface ToolCar {
/**
* 跑起来
*/
void run();
}
接着定义我们的产品
坦克
/**
* 坦克
*
* @author 编程还未
*/
public class Tank implements ToolCar {
/**
* 跑起来
*/
@Override
public void run() {
System.out.println("tank running");
}
}
拖拉机
/**
* 拖拉机
*
* @author 编程还未
*/
public class Tractor implements ToolCar {
/**
* 跑起来
*/
@Override
public void run() {
System.out.println("tractor running");
}
}
货车
/**
* 货车
* @author 编程还未
*/
public class Truck implements ToolCar {
/**
* 跑起来
*/
@Override
public void run() {
System.out.println("truck running");
}
}
2.2.颜色产品定义
我们需要为我们的工具车设置不同的颜色,以满足不同的需求。比如:树林用迷彩绿,沙漠地区用沙子黄,等等。
我们需要一个颜色接口
/**
* 颜色接口
*
* @author 编程还未
*/
public interface Color {
/**
* 填充颜色
*/
void fill();
}
颜色的三个实现类蓝、绿、红
/**
* 蓝色
*
* @author 编程还未
*/
public class Blue implements Color {
/**
* 填充颜色
*/
@Override
public void fill() {
System.out.println("Blue fill");
}
}
/**
* 绿色
*
* @author 编程还未
*/
public class Green implements Color {
/**
* 填充颜色
*/
@Override
public void fill() {
System.out.println("Green fill");
}
}
/**
* 红色
*
* @author 编程还未
*/
public class Red implements Color {
/**
* 填充颜色
*/
@Override
public void fill() {
System.out.println("red fill");
}
}
2.3.定义工厂类
抽象工厂
/**
* 抽象工厂类
*
* @author 编程还未
*/
public abstract class AbstractFactory {
/**
* 获取颜色
*
* @param type 颜色类型
* @return 颜色
*/
public abstract Color getColor(ColorFactory.Type type);
/**
* 获取工具车
*
* @param type 工具车类型
* @return 工具车
*/
public abstract ToolCar getToolCar(ToolCarFactory.Type type);
enum Type {
Color, ToolCar;
}
}
颜色工厂和工具车工厂
/**
* 颜色工厂
* <p>
* 可以生产:蓝色、绿色、红色
*
* @author 编程还未
*/
public class ColorFactory extends AbstractFactory {
/**
* 获取颜色
*
* @param type 颜色类型
* @return 颜色
*/
@Override
public Color getColor(Type type) {
if (type == null) {
return null;
}
if (Type.BLUE.equals(type)) {
return new Blue();
}
if (Type.GREEN.equals(type)) {
return new Green();
}
if (Type.RED.equals(type)) {
return new Red();
}
return null;
}
/**
* 获取工具车
*
* @param type 工具车类型
* @return 工具车
*/
@Override
public ToolCar getToolCar(ToolCarFactory.Type type) {
return null;
}
public enum Type {
BLUE, GREEN, RED;
}
}
/**
* 工具车工厂
* <p>
* 可以生产:坦克、拖拉机、货车
*
* @author 编程还未
*/
public class ToolCarFactory extends AbstractFactory {
/**
* 获取颜色
*
* @param type 颜色类型
* @return 颜色
*/
@Override
public Color getColor(ColorFactory.Type type) {
return null;
}
/**
* 获取工具车
*
* @param type 工具车类型
* @return 工具车
*/
@Override
public ToolCar getToolCar(Type type) {
if (Type.TANK.equals(type)) {
return new Tank();
} else if (Type.TRACTOR.equals(type)) {
return new Tractor();
} else if (Type.TRUCK.equals(type)) {
return new Truck();
}
//未知的类型返回null
return null;
}
/**
* 可以生产的类型
*/
public enum Type {
/**
* 坦克
*/
TANK,
/**
* 拖拉机
*/
TRACTOR,
/**
* 货车
*/
TRUCK;
}
}
产品生产者
/**
* 工厂生产者
*
* @author 编程还未
*/
public class FactoryProducer {
/**
* 获取子产品的工厂
*
* @param type 子产品类型
* @return 子工厂
*/
public static AbstractFactory getFactory(AbstractFactory.Type type) {
if (AbstractFactory.Type.Color.equals(type)) {
return new ColorFactory();
}
if (AbstractFactory.Type.ToolCar.equals(type)) {
return new ToolCarFactory();
}
return null;
}
}
测试抽象工厂
/**
* 测试抽象工厂
*
* @author 编程还未
*/
public class TestFactory {
public static void main(String[] args) {
AbstractFactory colorFactory = FactoryProducer.getFactory(AbstractFactory.Type.Color);
AbstractFactory toolCarFactory = FactoryProducer.getFactory(AbstractFactory.Type.ToolCar);
//蓝色
Color color1 = colorFactory.getColor(ColorFactory.Type.BLUE);
color1.fill();
//绿色
Color color2 = colorFactory.getColor(ColorFactory.Type.GREEN);
color2.fill();
//红色
Color color3 = colorFactory.getColor(ColorFactory.Type.RED);
color3.fill();
//现在有情况,需要几辆坦克
ToolCar toolCar1 = toolCarFactory.getToolCar(ToolCarFactory.Type.TANK);
toolCar1.run();
//和平安定,需要拖拉机生产
ToolCar toolCar2 = toolCarFactory.getToolCar(ToolCarFactory.Type.TRACTOR);
toolCar2.run();
//大丰收,需要货车运送货物
ToolCar toolCar3 = toolCarFactory.getToolCar(ToolCarFactory.Type.TRUCK);
toolCar3.run();
}
}