设计模式 - 抽象工厂模式

目录

一、官方话

二、自己概括

三、实现

四、代码

五、注意

---

一、官方话

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象

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

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

 

二、自己概括

该模式就是将一般工厂模式的工厂再建一个工厂，相当于工厂模式的嵌套。 用工厂模式来获得工厂，再用获得的工厂获得对象。

有点绕。

 

三、实现

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

 

四、代码

首先创建两个接口，形状及颜色：

public interface Shape {
    void draw();
}

public interface Color {
    void fill();
}

然后分别每个接口创建三个实现类：

public class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("This is circle draw!");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("This is rectangle draw!");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("This is square draw!");
    }
}

public class Green implements Color {
    @Override
    public void fill() {
        System.out.println("filled with green");
    }
}

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("filled with Red");
    }
}

public class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("filled with blue");
    }
}

创建一个抽象工厂类：

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

然后创建两个抽象工厂的扩展类，分别具体实现对应的抽象方法：

public class ShapeFactory extends AbstactFactory {
    @Override
    public Color getColor(String color) {
        return null;
    }

    @Override
    @SuppressWarnings("all")
    public Shape getShape(String type) {
        if(type == null){
            return null;
        }
        if(type.equalsIgnoreCase("circle")){
            return new Circle();
        }else if(type.equalsIgnoreCase("rectangle")){
            return new Rectangle();
        }else if (type.equalsIgnoreCase("square")){
            return new Square();
        }
        return null;
    }
}

public class ColorFactory extends AbstactFactory {
    @Override
    public Color getColor(String type) {
        if(type == null){
            return null;
        }
        if(type.equalsIgnoreCase("red")){
            return new Red();
        }else if(type.equalsIgnoreCase("green")){
            return new Green();
        }else if (type.equalsIgnoreCase("blue")){
            return new Blue();
        }
        return null;
    }

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

最后创建一个工厂生产器类：

public class FactoryPrducer {
    public static AbstactFactory getFactory(String name){
        if(name.equalsIgnoreCase("shape")){
            return new ShapeFactory();
        }else if(name.equalsIgnoreCase("color")){
            return new ColorFactory();
        }
        return null;
    }
}

实现了可以根据工厂名称获取对应的工厂，获得的工厂可以用来根据名称获取对象。

测试一下：

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

        AbstactFactory shapeFactory = FactoryPrducer.getFactory("shape");
        Shape shape1 = shapeFactory.getShape("circle");
        shape1.draw();

        AbstactFactory colorFactory = FactoryPrducer.getFactory("color");
        Color color1 = colorFactory.getColor("Red");
        color1.fill();
    }
}

结果：

 

五、注意

同样，简单能创建的对象不适用该模式