设计模式——抽象工厂模式

一、简介

• 1、为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构；

• 2、抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品；

• 3、将工厂抽象两层，AbsFactory(抽象工厂) 和 具体实现的工厂子类。程序员可以根据创建对象类型使用对应的工厂类。这样将简单的工厂类变成了工厂簇，更利于代码的维护和扩展。

• 4、使用抽象工厂模式一般要满足以下条件：

  • 系统中有多个产品族， 每个具体工厂创建同族但属于不同等级的产品；
  • 系统一次只可能消费其中某一族产品，即同族的产品一起使用。

---

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

主要解决： 主要解决接口选择的问题。

何时使用： 系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

使用场景： 1、QQ 换皮肤，一整套一起换。 2、生成不同操作系统的程序。

---

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

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

注意事项： 产品族难扩展，产品等级易扩展。

二、代码实现

就是将原本只有一个工厂的工厂模式，变成多个工厂，形成工厂簇，然后再弄一个工厂去跳转指定工厂簇的哪一个工厂。

步骤一：
为形状创建一个接口。

interface Shape {
	void draw(); // 画图接口
}

步骤 二：

具体细节都写在实现类上，多个就多个实现类

// 长方形类
class Rectangle implements Shape{
	@Override
	public void draw() {
		System.out.println("这是一个画长方形的具体方法");
	}
}

// 正方形类
class Square implements Shape{
	@Override
	public void draw() {
		System.out.println("这是一个画正方形的具体方法");
	}
}

// 圆形类
class Circle implements Shape{
	@Override
	public void draw() {
		System.out.println("这是一个画圆形的具体方法");
	}

步骤 三：

为颜色创建一个接口。

interface Color {
	void fill(); //填充接口
}

步骤 四：

具体细节都写在实现类上，多个就多个实现类

 class Red implements Color {
	@Override
	public void fill() {
		System.out.println("填充红色");
	}
}

 class Green implements Color {
	@Override
	public void fill() {
		System.out.println("填充绿色");
	}
}

 class Blue implements Color {
	@Override
	public void fill() {
		System.out.println("填充蓝色");
	}
}

步骤 五

为 Color 和 Shape 对象创建抽象类来获取工厂。

abstract class AbstractFactory{
	public abstract Color getColor(String color);
	public abstract Shape getShape(String shape);
}

步骤 六

创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。

画图的工厂类

 class ShapeFactory extends AbstractFactory {
	 @Override
	 public Shape getShape(String shapeType){
		 if(shapeType == null){
			 return null;
		 }
		 if(shapeType.equalsIgnoreCase("CIRCLE")){
			 return new Circle();
		 } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
			 return new Rectangle();
		 } else if(shapeType.equalsIgnoreCase("SQUARE")){
			 return new Square();
		 }
		 return null;
	 }

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

填充颜色的工厂类

class ColorFactory extends AbstractFactory {

	@Override
	public Shape getShape(String shapeType){
		return null;
	}

	@Override
	public Color getColor(String color) {
		if(color == null){
			return null;
		}
		if(color.equalsIgnoreCase("RED")){
			return new Red();
		} else if(color.equalsIgnoreCase("GREEN")){
			return new Green();
		} else if(color.equalsIgnoreCase("BLUE")){
			return new Blue();
		}
		return null;
	}
}

步骤 七

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

class FactoryProducer {
	public static AbstractFactory getFactory(String choice){
		if(choice.equalsIgnoreCase("SHAPE")){
			return new ShapeFactory();
		} else if(choice.equalsIgnoreCase("COLOR")){
			return new ColorFactory();
		}
		return null;
	}
}

步骤 八

使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象。

class AbstractFactoryPatternDemo {
	public static void main(String[] args) {

		//获取形状工厂
		AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

		//获取形状为 Circle 的对象
		Shape shape1 = shapeFactory.getShape("CIRCLE");

		//调用 Circle 的 draw 方法
		shape1.draw();

		//获取形状为 Rectangle 的对象
		Shape shape2 = shapeFactory.getShape("RECTANGLE");

		//调用 Rectangle 的 draw 方法
		shape2.draw();

		//获取形状为 Square 的对象
		Shape shape3 = shapeFactory.getShape("SQUARE");

		//调用 Square 的 draw 方法
		shape3.draw();

		//获取颜色工厂
		AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

		//获取颜色为 Red 的对象
		Color color1 = colorFactory.getColor("RED");

		//调用 Red 的 fill 方法
		color1.fill();

		//获取颜色为 Green 的对象
		Color color2 = colorFactory.getColor("GREEN");

		//调用 Green 的 fill 方法
		color2.fill();

		//获取颜色为 Blue 的对象
		Color color3 = colorFactory.getColor("BLUE");

		//调用 Blue 的 fill 方法
		color3.fill();
	}
}

输出

三、jdk中使用到的抽象工厂模式