设计模式——工厂方法模式

工厂方法模式是什么？

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化延迟到子类。

工厂方法模式解决什么问题？

现有一家果汁店，原本只经营一种果汁，顾客通过orderJuice()方法点果汁：

public class Juice {

    public void Box() {
        System.out.println("装盒");
    }

    public void Cover() {
        System.out.println("封盖");
    }

    public void Bag() {
        System.out.println("装袋");
    }
}

class JuiceStore {

    Juice orderJuice() {

        Juice juice = new Juice();
        juice.Box();
        juice.Cover();
        juice.Bag();
        return juice;
    }
}

如今业务扩张，需要出新品，在orderJuice()方法中加入判断根据顾客需要制作：

public class Juice {

    public void Box() {
        System.out.println("装盒");
    }

    public void Cover() {
        System.out.println("封盖");
    }

    public void Bag() {
        System.out.println("装袋");
    }
}
class AppleJuice extends Juice {

}

class BananaJuice extends Juice {

}

class JuiceStore {

    Juice orderJuice(String fruit) {

        Juice juice = null;
         switch (fruit) {
            case "apple":
                juice = new AppleJuice();
                break;
            case "banana":
                juice = new BananaJuice();
                break;
            default:
                juice = new Juice();
                break;
        }
        juice.Box();
        juice.Cover();
        juice.Bag();
        return juice;
    }
}

• problem1：每当出新品时都需要修改JuiceStore中的orderJuice()代码

简单工厂实现

为了减少对JuiceStore源代码的修改，将orderJuice()中需要改变的代码抽出到SimpleJuiceFactory。

class SimpleJuiceFactory {
    public Juice createJuice(String fruit) {
        switch (fruit) {
            case "apple":
                return new AppleJuice();
            case "banana":
                return new BananaJuice();
            default:
                return new Juice();
        }
    }
}

class JuiceStore {

    SimpleJuiceFactory factory;

    public JuiceStore(SimpleJuiceFactory factory) {
        this.factory = factory;
    }

    public Juice orderJuice(String fruit) {
        Juice juice;
        juice = factory.createJuice(fruit);
        juice.Box();
        juice.Cover();
        juice.Bag();
        return juice;
    }
}

生产过程：

SimpleJuiceFactory factory=new SimpleJuiceFactory();
JuiceStore store=new JuiceStore(factory);
store.orderJuice("apple");

简单工厂并不是设计模式，只是一种编程习惯，实际并没有解决问题，只是将问题转移到SimpleJuiceFactory中。

工厂方法模式实现

将JuiceStore中的createJuice()方法声明为抽象方法，由子类型自己生产：

abstract class JuiceStore {

    public Juice orderJuice(String fruit) {
        Juice juice;
        juice = createJuice(fruit);
        juice.Box();
        juice.Cover();
        juice.Bag();
        return juice;
    }

    abstract Juice createJuice(String fruit);
}

创建JuiceFactory 重写createJuice()方法：

class JuiceFactory extends JuiceStore {

    @Override
    Juice createJuice(String fruit) {
        switch (fruit) {
            case "apple":
                return new AppleJuice();
            case "banana":
                return new BananaJuice();
            default:
                return null;
        }
    }
}

生产过程：

JuiceStore store=new JuiceFactory();
store.orderJuice("apple");

有何区别？

• 简单工厂实现：产品（Juice）的创建类依旧是JuiceStore，针对实例编程，无法运行时改变，JuiceStore依赖SimpleJuiceFactory才能创建
• 工厂方法实现：产品（Juice）的创建类变成了JuiceFactory，将创建方法延迟到子类实现，且使用多态可以运行时绑定