简单工厂模式

介绍

在简单工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

什么时候使用：我们明确计划不同条件下创建不同实例时。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。

实现

创建一个接口

public interface Shape {

    void draw();
}

创建实现接口的实体类

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("画圆");
    }
}

public class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("画正方形");
    }
}

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画长方形");
    }
}

创建工厂类

public class ShapeFactory {
    public Shape getShape(String shapeType){
        Shape shape = null;
        switch (shapeType){
            case "CIRCLE":
                shape = new Circle();
                break;
            case "SQUARE":
                shape = new Square();
                break;
            case "RECTANGLE":
                shape = new Rectangle();
                break;
            default:
                break;
        }
        return shape;
    }
}

使用该工厂，通过传递类型信息来获取实体类的对象。

public class SimpleFactoryDemo {

    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();

        Shape circle = shapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape square = shapeFactory.getShape("SQUARE");
        square.draw();

        Shape rectangle = shapeFactory.getShape("RECTANGLE");
        rectangle.draw();
    }
}

抽象工厂模式

介绍

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。【对应现实生活中就是有一家大厂，有不同的部门，每个部门生产不同的产品】

什么时候使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

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

缺点：不利于扩展，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

实现

除了上述已创建的接口和实体类，我们再创建一个新的颜色接口

public interface Color {
    void fill();
}

实现接口的实体类

public class Red implements Color {
    @Override
    public void fill() {
        System.out.println("填充红色");
    }
}

public class Orange implements Color {
    @Override
    public void fill() {
        System.out.println("填充橙色");
    }
}

为 Color 和 Shape 对象创建抽象类来获取工厂。

public abstract class AbstractFactory {
    public abstract Color getColor(String colorType);
    public abstract Shape getShape(String shapeType);
}

基于给定的信息生成对应的实体类。

public class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String colorType) {
        Color color = null;
        switch (colorType){
            case "RED":
                color = new Red();
                break;
            case "ORANGE":
                color = new Orange();
                break;
            default:
                break;
        }
        return color;
    }

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

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

    @Override
    public Shape getShape(String shapeType){
        Shape shape = null;
        switch (shapeType){
            case "CIRCLE":
                shape = new Circle();
                break;
            case "SQUARE":
                shape = new Square();
                break;
            case "RECTANGLE":
                shape = new Rectangle();
                break;
            default:
                break;
        }
        return shape;
    }
}

创建一个工厂生成器。

public class FactoryProducer {
    public static AbstractFactory getFactory(String choice){
        if("SHAPE".equalsIgnoreCase(choice)){
            return new ShapeFactory();
        } else if("COLOR".equalsIgnoreCase(choice)){
            return new ColorFactory();
        }
        return null;
    }
}

使用

public class AbstractFactoryDemo {

    public static void main(String[] args) {
        AbstractFactory shapeFactory = FactoryProducer.getFactory("shape");

        AbstractFactory colorFactory = FactoryProducer.getFactory("color");

        Shape shape = shapeFactory.getShape("CIRCLE");

        Color color = colorFactory.getColor("RED");

        shape.draw();

        color.fill();
    }
}

小结

工厂模式的意义：将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目的依赖关系的解耦。从而提高项目的扩展和维护性。在任何需要生成复杂对象的地方，都可以使用工厂方法模式，只需要通过 new 就可以完成创建的对象不要硬套设计模式。