抽象工厂模式

 抽象工厂模式：

　　抽象工厂模式是指当有多个抽象角色时，使用的一种工厂模式。通过一个工厂的生成器来创建所需要的工厂，再由对应的工厂创建对应的对象。缺点：当需要扩展时，需要在原先的代码上进行扩展，容易把原先的代码误操作改掉。

//为颜色创建接口
public interface Color {
    public abstract void addColor();
}

public class Red implements Color {
    @Override
    public void addColor() {
        System.out.println("Red::addColor() method");
    }
}

public class Blue implements Color{
    @Override
    public void addColor() {
        System.out.println("Blue::addColor() method");
    }

}

//为形状创建接口
public interface Shape {
    public abstract void draw();
}

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Square::draw() method");
    }

}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle::draw() method");
    }

}

//为Color和Shape对象创建抽象类类获取工厂
public abstract class AbstractFactory {
    public abstract Color getColor(String color);
    public abstract Shape getShape(String sharp);
}

//颜色的工厂
public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("BLUE")) {
            return new Blue();
        }
        return null;
    }

    @Override
    public Shape getShape(String sharp) {
        // TODO Auto-generated method stub
        return null;
    }
}

//形状的工厂
public class ShapeFactory extends AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        } 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;
    }
}

//创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂。
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;
   }
}

测试类：

//测试类
//使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象
public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {

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

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

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

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

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

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

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

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


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

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

运行结果：

Rectangle::draw() method
Square::draw() method
Red::addColor() method
Blue::addColor() method

UML图：

　　

 。