1.2（设计模式）抽象工厂

抽象工厂

抽象工厂模式，先将所有工厂需要的操作抽象出来形成一个抽象工厂类（AbstractFactory）。

所以工厂类都继承AbstractFactory。

后续通过FactoryProduct创建工厂类，返回的类型为AbstractFactory，（所有工厂类都是抽象工厂的子类）

最后通过具体的工厂类创建对象。

Shape接口

public interface Shape {
    public void draw();
}

Shape接口实现类：

Circle.java

public class Circle implements Shape{

    @Override
    public void draw() {
        System.out.println("draw cilcle");   
    }
}

Color接口

public interface Color {
    public void fill();
}

Color接口的实现类

Red.java

public class Red implements Color{

    @Override
    public void fill() {
        System.out.println("fill red");
    }    
}

以上是工厂模式。 

AbstractFactory

定义了获取Shape和获取Color的方法，（将所有工厂中的创建操作抽取出来）

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

ShapeFactory  继承AbastractFactory  （具体的工厂类继承抽象工厂）

public class ShapeFactory extends AbstractFactory{

    @Override
    public Shape getShape(String shape) {
        if("circle".equals(shape)) {
            return new Circle();
        }
        return null;
    }

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

}

ShapeFactory根据String shape实施化对应对象。

ColorFactroy 继承AbastractFactory

public class ColorFactory extends AbstractFactory{

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

    @Override
    public Color getColor(String color) {
        if("red".equals(color)) {
            return new Red();
        }
        return null;
    }
}

根据color实例化对应对象。

FactoryProducer   根据factory获取对应的工厂，后续通过工厂实例化对应对象。（FactoryProduct用于创建工厂类）

public class FactroyProducer {
    public static AbstractFactory getFactory(String factory) {
        if("shape".equals(factory)) {
            return new ShapeFactory();
        }else if("color".equals(factory)) {
            return new ColorFactory();
        }
        return null;
    }
}

Main

public class Main {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactroyProducer.getFactory("shape"); //获取shape工厂
        Shape circle = shapeFactory.getShape("circle");  //使用shape工厂实例化circle
        circle.draw(); 
        AbstractFactory colorFactory = FactroyProducer.getFactory("color");  //获取color工厂
        Color red = colorFactory.getColor("red");  //获取颜色
        red.fill();
        
    }
}

运行结果：
draw cilcle
fill red

上述获取工厂，以及从工厂过去对象都是通过字符串进行判断，而且采用if else后续分支过多可读写不强。

可采用枚举类型配合switch语句扩展。

ShapeEnum

enum ShapeEnum {
    CIRCLE,RECTANGLE,SQUARE
}

ColorEnum

public enum ColorEnum {
    RED,BULE
}

FactoryEnum

public enum FactoryEnum {
    SHAPE,COLOR
}

ShapeFactory

public class ShapeFactory extends AbstractFactory{

    @Override
    public Shape getShape(ShapeEnum shape) {
        switch (shape) {
        case CIRCLE:
            return new Circle();
        default:   //没有找到类则抛出异常
            try {
                throw new ClassNotFoundException();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }

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

}

ColorFactory

public class ColorFactory extends AbstractFactory{

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

    @Override
    public Color getColor(ColorEnum color) {
        switch(color) {
        case RED: return new Red();
        default : try {
                throw new ClassNotFoundException();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }

}

FactoryProduct

public class FactroyProducer {
    public static AbstractFactory getFactory(FactoryEnum factory) {
        switch (factory) {
        case SHAPE:
            return new ShapeFactory();
        case COLOR:
            return new ColorFactory();
        default:
            try {
                throw new ClassNotFoundException();
            } catch (ClassNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }
}

Main

public class Main {
    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactroyProducer.getFactory(FactoryEnum.SHAPE); 
        Shape circle = shapeFactory.getShape(ShapeEnum.CIRCLE);
        circle.draw();
        AbstractFactory colorFactory = FactroyProducer.getFactory(FactoryEnum.COLOR);
        Color red = colorFactory.getColor(ColorEnum.RED);
        red.fill();
        
    }
}

运行结果：
draw cilcle
fill red

参考资料：

http://www.runoob.com/design-pattern/abstract-factory-pattern.html