Java设计模式-工厂模式

工厂模式

概述

“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”(在基类中定义创建对象的一个接口，让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。)

优点

1. 解耦 ：把对象的创建和使用的过程分开
2. 降低代码重复：如果创建某个对象的过程都很复杂，需要一定的代码量，而且很多地方都要用到，那么就会有很多的重复代码。
3. 降低维护成本：由于创建过程都由工厂统一管理，所以发生业务逻辑变化，不需要找到所有需要创建对象B的地方去逐个修正，只需要在工厂里修改即可，降低维护成本。

分类

1. 简单工厂（Simple Factory）模式，又称静态工厂方法模式（Static Factory Method Pattern）
2. 工厂方法（Factory Method）模式，又称多态性工厂（Polymorphic Factory）模式或虚拟构造子（Virtual Constructor）模式；
3. 抽象工厂（Abstract Factory）模式，又称工具箱（Kit 或Toolkit）模式。

实例对象

基础接口

/**
 * 基础形状接口
 */
public interface Shape {
    void draw();
}

实体对象

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

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

简单工厂

简单工厂模式违背了我们在概述中说的 开放-封闭原则 （虽然可以通过反射的机制来避免） 。因为每次添加一个功能，都需要在生switch-case 语句（或者if-else 语句）中去修改代码，添加分支条件。

/**
 * 简单工厂模式
 * 形状工厂
 */
public class SimpleFactory {
    // 使用 getShape 方法获取形状类型的对象
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("Circle")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("Rectangle")) {
            return new Rectangle();
        }
        return null;
    }


    public static void main(String[] args) {
        // 获取 Circle 的对象，并调用它的 draw 方法
        Shape circle = SimpleFactory.getShape("CIRCLE");
        circle.draw();

        // 获取 Rectangle 的对象，并调用它的 draw 方法
        Shape rectangle = SimpleFactory.getShape("RECTANGLE");
        rectangle.draw();
    }


}

使用反射机制改善简单工厂

利用反射解决简单工厂每次增加新了产品类都要修改产品工厂的弊端

/**
 * 简单工厂模式
 * 形状工厂 (反射)
 */
public class SimpleReflexFactory {
    public static Object getClass(Class<? extends Shape> clazz) {
        Object obj = null;

        try {
            obj = Class.forName(clazz.getName()).newInstance();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return obj;
    }



    public static void main(String[] args) {
        Circle circle = (Circle) SimpleReflexFactory.getClass(Circle.class);
        circle.draw();

        Rectangle rectangle = (Rectangle) SimpleReflexFactory.getClass(Rectangle.class);
        rectangle.draw();
    }


}

工厂方法

工厂方法模式应该是在工厂模式家族中是用的最多模式，一般项目中存在最多的就是这个模式。

工厂方法模式是简单工厂的仅一步深化， 在工厂方法模式中，我们不再提供一个统一的工厂类来创建所有的对象，而是针对不同的对象提供不同的工厂，每个对象都有一个与之对应的工厂 。

工厂结构图

具体实现

/**
 * 基础工厂接口
 */
public interface Factory {
    public Shape getShape();
}

/**
 * 圆形工厂
 */
public class CircleFactory implements Factory {

    @Override
    public Shape getShape() {
        return new Circle();
    }

}

/**
 * 长方形工厂
 */
public class RectangleFactory implements Factory{
    @Override
    public Shape getShape() {
        return new Rectangle();
    }

}

/**
 * 工厂方法测试类
 */
public class FunctionFactoryTest {
    public static void main(String[] args) {
        Factory circleFactory = new CircleFactory();
        Shape circleShape = circleFactory.getShape();
        circleShape.draw();

        Factory rectangleFactory = new RectangleFactory();
        Shape rectangleShape = rectangleFactory.getShape();
        rectangleShape.draw();
    }
}

抽象工厂

在工厂方法模式中，其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品。抽象工厂模式是工厂方法的仅一步深化，在这个模式中的工厂类不单单可以创建一种产品，而是可以创建一组产品。

抽象工厂应该是比较最难理解的一个工厂模式了。

实体结构

我们知道汽车是由发动机，轮胎和若干组件构成，我们以此比喻抽象工厂创建一组产品。

发动机相关

/**
 * 发动机接口
 */
public interface Engine {
    public void running();
}

/**
 * 货车发动机实现类
 */
public class TruckEngine implements Engine{
    @Override
    public void running() {
        System.out.println("Running with truck");
    }
}

/**
 * 客车发动机实现类
 */
public class BusEngine implements Engine{
    @Override
    public void running() {
        System.out.println("Running with bus");
    }
}

轮胎相关

/**
 * 轮胎接口
 */
public interface Tire {
    public void scroll();
}

/**
 * 货车轮胎实现类
 */
public class TruckTire implements Tire {
    @Override
    public void scroll() {
        System.out.println("Scroll with truck");
    }
}

/**
 * 客车轮胎实现类
 */
public class BusTire implements Tire {
    @Override
    public void scroll() {
        System.out.println("Scroll with bus");
    }
}

工厂结构

/**
 * 抽象工厂接口，生产发动机和轮胎
 */
public interface AbstractFactory {
    //生产发动机
    public Engine produceEngine();
    //生产轮胎
    public Tire produceTire();
}

/**
 * 货车工厂
 */
public class TruckFactory implements AbstractFactory {
    @Override
    public Engine produceEngine() {
        return new TruckEngine();
    }

    @Override
    public Tire produceTire() {
        return new TruckTire();
    }
}

/**
 * 客车工厂
 */
public class BusFactory implements AbstractFactory {
    @Override
    public Engine produceEngine() {
        return new BusEngine();
    }

    @Override
    public Tire produceTire() {
        return new BusTire();
    }
}

/**
 * 抽象工厂测试类
 */
public class AbstractFactoryTest {
    public static void main(String[] args) {
        //客车
        AbstractFactory busFactory = new BusFactory();
        Engine busEngine = busFactory.produceEngine();
        busEngine.running();
        Tire busTire = busFactory.produceTire();
        busTire.scroll();
        //货车
        AbstractFactory truckFactory = new TruckFactory();
        Engine truckEngine = truckFactory.produceEngine();
        truckEngine.running();
        Tire truckTire = truckFactory.produceTire();
        truckTire.scroll();

    }
}

我的公众号

程序员进化之路，从一个简单的公众号开始