java设计模式-创建型模式-工厂方法模式

工厂方法模式

工厂方法模式，是在简单工厂的基础上，弥补了简单工厂的缺点（新增加需要被创建的对象需要修改工厂类，违背开闭原则）
工厂方法模式不再通过一个工厂来创建各种对象，而是针对每一个对象，创建一个对应的工厂

四个角色

• 抽象工厂类：定义了抽象工厂方法
• 具体工厂类：抽象工厂类的子类，实现抽象工厂方法，返回具体对象的实例
• 抽象对象类：抽象工厂类定义的抽象工厂方法返回的对象类型，是所有具体对象类的父类
• 具体对象类：抽象对象类的子类，是具体工厂类产出的对象

例子

有一条汽车生产车间，各个生产线生产各自的零件，发动机生产线、方向盘生产线、轮子生产线等，利用工厂方法模式来模拟。

• 抽象对象类

public interface Product {

    void display();
}

• 具体对象类

public class Engine implements Product {

    /**
     * 发动机缸数
     */
    private Integer cylinder;

    /**
     * 发动机大小
     */
    private String size;

    public Integer getCylinder() {
        return cylinder;
    }

    public void setCylinder(Integer cylinder) {
        this.cylinder = cylinder;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }

    @Override
    public void display() {
        System.out.println("新发动机[ 缸数：" + cylinder + "，大小：" + size + " ]");
    }
}

public class Wheel implements Product {

    /**
     * 类型
     */
    private String type;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public void display() {
        System.out.println("轮子[ 类型：" + type + " ]");
    }
}

• 抽象工厂类

public interface Factory {

    /**
     * 产出
     * @return
     */
    Product produce();
}

• 具体工厂类

public class EngineFactory implements Factory {
    @Override
    public Product produce() {
        Engine engine = new Engine();
        engine.setCylinder(4);
        engine.setSize("normal");
        return engine;
    }
}

public class WheelFactory implements Factory {
    @Override
    public Product produce() {
        Wheel wheel = new Wheel();
        wheel.setType("normal");
        return wheel;
    }
}

• 测试

public class Main {

    public static void main(String[] args) {
        Factory factory = new EngineFactory();
        Product engine = factory.produce();
        engine.display();

        factory = new WheelFactory();
        Product wheel = factory.produce();
        wheel.display();
    }
}

• 结果

新发动机[ 缸数：4，大小：normal ]
轮子[ 类型：normal ]

总结

优点：如果新增加类，不需要修改原有的代码，符合开闭原则。对象的实例化隐藏了具体细节，将重复的初始化步骤放在工厂类中。
缺点：类会成对增加，编写具体对象类还需要编写对应的工厂类，增加了代码量。

回到主目录