【设计模式】- 工厂模式

工厂模式分为三种：
简单工厂模式、工厂方法模式和抽象工厂模式。

工厂模式：靠工厂生产对象

简单工厂模式中只有一个工厂类来对应这些产品，不符合开闭原则，每增加一个具体产品，都需要修改工厂类。
开闭原则对扩展开放，对修改关闭
工厂方法模式 当新的产品出现，只需要增加对应具体产品类和工厂类，符合开闭原则。

抽象工厂模式 对于系统中存在不同的产品树，而且产品树上存在产品族（下一节将解释这个名词）。那么这种情况下就可能可以使用抽象工厂模式了。

简单工厂模式

/**
 * "抽象产品
 */
public interface Shap {

    void draw();
}

/**
 * 具体产品
 */
public class Circle implements Shap {
    @Override
    public void draw() {
        System.out.println("Circle draw...");
    }
}

/**
 * 具体产品
 */
public class Rectangle implements Shap {

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

/**
 * 简单工厂
 */
public class ShapFactory {

    public Shap getShap(String shapType) {
        if (Strings.isEmpty(shapType)) {
            return null;
        }
        if (shapType.equalsIgnoreCase("circle")) {
            return new Circle();
        }
        if (shapType.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        }
        return null;
    }
}

/**
 * 测试类
 */
public class FactoryPatternDemo {

    public static void main(String[] args) {
        ShapFactory shapFactory = new ShapFactory();

        shapFactory.getShap("circle").draw();
        shapFactory.getShap("square").draw();
        shapFactory.getShap("rectangle").draw();
    }
}

工厂方法模式

/**
 * "抽象产品
 */
public interface Shap {

    void draw();
}

/**
 * 具体产品
 */
public class Square implements Shap {

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

/**
 * 具体产品
 */
public class Circle implements Shap {
    @Override
    public void draw() {
        System.out.println("Circle draw...");
    }
}

/**
 * 抽象工厂
 */
public abstract class AbstractShapFactory {

    public abstract Shap getShap();
}

/**
 * 具体工厂
 */
public class CircleFactory extends AbstractShapFactory {

    @Override
    public Shap getShap() {
        return new Circle();
    }
}

/**
 * 具体工厂
 */
public class SquareFactory extends AbstractShapFactory {

    @Override
    public Shap getShap() {
        return new Square();
    }
}

/**
 * 测试类
 */
public class FactoryPatternDemo {

    public static void main(String[] args) {
        AbstractShapFactory circleFactory = new CircleFactory();
        circleFactory.getShap().draw();

        AbstractShapFactory squareFactory = new SquareFactory();
        squareFactory.getShap().draw();
    }
}

抽象工厂模式

/**
 * 抽象产品
 */
public interface Color {

    void fill();
}

/**
 * 具体产品
 */
public class Blue implements Color {

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

/**
 * 具体产品
 */
public class Green implements Color {

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

/**
 * 抽象产品
 */
public interface Shap {

    void draw();
}

/**
 * 具体产品
 */
public class Circle implements Shap {

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

/**
 * 具体产品
 */
public class Rectangle implements Shap {

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

/**
 * 抽象工厂
 */
public abstract class AbstractFactory {

    public abstract Color getColor(String color);

    public abstract Shap getShap(String shap);
}

/**
 * 具体工厂
 */
public class ColorFactory extends AbstractFactory {

    @Override
    public Color getColor(String color) {
        if (Strings.isEmpty(color)) {
            return null;
        }
        if (color.equalsIgnoreCase("blue")) {
            return new Blue();
        }
        if (color.equalsIgnoreCase("green")) {
            return new Green();
        }
        return null;
    }

    @Override
    public Shap getShap(String shap) {
        return null;
    }
}

/**
 * 具体工厂
 */
public class ShapFactory extends AbstractFactory {

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

    @Override
    public Shap getShap(String shap) {
        if (Strings.isEmpty(shap)) {
            return null;
        }
        if (shap.equalsIgnoreCase("rectangle")) {
            return new Rectangle();
        }
        if (shap.equalsIgnoreCase("circle")) {
            return new Circle();
        }
        return null;
    }
}

/**
 * 不同类型工厂生产
 */
public class FactoryProductor {

    public AbstractFactory getFactory(String factoryType) {
        if ("shap".equalsIgnoreCase(factoryType)) {
            return new ShapFactory();
        }
        if ("color".equalsIgnoreCase(factoryType)) {
            return new ColorFactory();
        }
        return null;
    }
}

/**
 * 测试类
 */
public class AbstractFactoryPatternDemo {

    public static void main(String[] args) {
        AbstractFactory colorFactory = FactoryProducer.getFactory("color");
        colorFactory.getColor("red").fill();
        colorFactory.getColor("green").fill();
        colorFactory.getColor("blue").fill();

        AbstractFactory shapFactory = FactoryProducer.getFactory("shap");
        shapFactory.getShap("circle").draw();
        shapFactory.getShap("rectangle").draw();
        shapFactory.getShap("square").draw();
    }
}

参考文章https://www.jianshu.com/p/f6e419b92809