抽象工厂模式(Abstract Factory Pattern)
抽象工厂模式与工厂模式类似,也属于创建型模式,提供了创建对象的最佳方式。
抽象工厂实际上是围绕一个超级工厂创建其他工厂,而这个超级工厂本身又是其他工厂的工厂。抽象工厂模式中的接口负责创建一个相关对象的工厂,生成的每一个工厂都能按照工厂模式提供对象。
还是先简单举个例子理解一下抽象工厂模式。
抽象工厂设计模式我把它理解为文件夹模式,在此我们只考虑3层文件夹。比如C盘下有一个文件夹叫做Abs,这个文件夹下又包含了Fac1和Fac2两个文件夹,这两个文件夹里分别放了若干个同一类(在此体现为同一后缀名)的子文件。那么在此情境下,Abs文件夹就对应于抽象工厂模式中抽象工厂,它里边的两个子文件夹就相当于继承了Abs的两个工厂类。而最底层的那些子文件就相当于一个个的实体类。这里没有指出工厂制造器的概念,但它不难理解。我们直接实现类图就OK。
类图如下所示:
第一步:创建形状接口
public interface Shape {
void draw(); //声明一个方法
}
第二步:创建实现形状接口的实体类
public class Rectangle implements Shape {
@Override
public void draw() { // 重写接口方法,输出区分语句
System.out.println("Inside Rectangle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() { // 重写接口方法,输出区分语句
System.out.println("Inside Square::draw() method.");
}
}
public class Circle implements Shape {
@Override
public void draw() { // 重写接口方法,输出区分语句
System.out.println("Inside Circle::draw() method.");
}
}
第三步:创建颜色接口
public interface Color {
void fill(); //创建方式和Shape相同
}
第四步:创建实现颜色接口的实体类
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}
第五步:为Shape和Color创建抽象类(抽象工厂)获取工厂
public abstract class AbstractFactory {
public abstract Color getColor(String color); // 抽象方法,返回值为Color对象
public abstract Shape getShape(String shape) ; // 抽象方法,返回值为Shape对象
}
第六步:创建扩展了AbstractFactory的工厂类,基于给定信息生成实体类的对象
public 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) { //因为这是形状工厂类,所以getColor方法不予实现,但必须重写
return null;
}
}
public class ColorFactory extends AbstractFactory { // 此类与形状工厂类类似,不再赘述
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
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;
}
}
第七步:创建一个工厂制造器,通过传递形状或颜色信息来获取工厂
public 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; // 传入其他非法字符返回空
}
}
第八步:编写测试用例,测试功能是否实现
public 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();
}
}
第九步:验证输出
Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.
总结一下抽象工厂模式:
应用场景:系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。
关键代码:在一个工厂里聚合多个同类产品。
优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。
缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。