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

设计模式—抽象工厂模式

1.什么是抽象工厂模式
抽象工厂模式是围绕一个超级工厂创建其它工厂，是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

2.角色分析

• 抽象工厂：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品；
• 具体工厂：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建；
• 抽象产品：定义了产品的特征接口，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品；
• 具体产品：实现了抽象产品中所定义的接口，由具体工厂来创建，它和具体工厂之间是多对一的关系。

3.代码实现
下面实例通过两个产品（Shape和Color）进行实现
①抽象产品

//抽象产品—Shape
public interface Shape {
    void draw();
}
//----------------------------------
//抽象产品—Color
public interface Color {
    void fill();
}

②具体产品

//Shape的具体产品—Rectangle
public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Shape draw 画了一个矩形......");
    }
}
//---
//Shape的具体产品-Circle
public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Shape draw 画了一个圆形......");
    }
}
//---------------------

//Color的具体产品—Red
public class Red implements Color{
    @Override
    public void fill() {
        System.out.println("Color fill 填充了红色......");
    }
}
//---
//Color的具体产品—Yellow
public class Yellow implements Color {
    @Override
    public void fill() {
        System.out.println("Color fill 填充了黄色......");
    }
}

③抽象工厂

//获取工厂的抽象类
public interface AbStractFactory {
    public Shape getShape(String shape);
    public Color getColor(String color);
}

④具体工厂

//具体工厂—Shape工厂
public class ShapeFactory implements AbStractFactory {
    @Override
    public Shape getShape(String shape) {
        if(shape.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        } else if(shape.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        }
        return null;
    }

    @Override
    public Color getColor(String color) {
        return null;
    }
}
//------------------------
//具体工厂—Color工厂
public class ColorFactory implements AbStractFactory{
    @Override
    public Color getColor(String color) {
        if(color.equalsIgnoreCase("RED")){
            return new Red();
        } else if (color.equalsIgnoreCase("YELLOW")) {
            return new Yellow();
        }
        return null;
    }

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

⑤工厂生成器

public class FactoryProducer {
    //获取具体的产品工厂
    public static AbStractFactory getFactory(String factory){
        if (factory.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (factory.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }
        return null;
    }

⑥测试

public class Test {
    public static void main(String[] args) {
        //获取Shape工厂
        AbStractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

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

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

        //获取Color工厂
        AbStractFactory colorFactory = FactoryProducer.getFactory("COLOR");

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

        //获取Color为Yellow的对象
        Color color2 = colorFactory.getColor("YELLOW");
        color2.fill();
    }
}

运行结果：

4.总结
由实现过程可以知道，抽象工厂模式在工厂方法模式的基础上将产品工厂这一层再次进行了封装，这样做的好处是，需要什么产品就创建相应的产品工厂，再通过产品工厂去创建对应的产品。