Java设计模式之工厂方法模式

　　GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory），将简单工厂模式（Simple Factory）视为工厂方法模式的一种特例，两者归为一类。 本文主要讲述工厂方法模式。
　　
　　下面以客户需要宝马车的例子进行说明：

最原始的方式

不同型号的宝马车:

public abstract class BMW {
}

public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("BMW320 has been made.");
    }
}

public class BMW523 extends BMW {
    public BMW523() {
        System.out.println("BMW523 has been made.");
    }
}

客户自己制造:

public class Customer {  
    public static void main(String[] args) {  
        BMW320 bmw320 = new BMW320();  
        BMW523 bmw523 = new BMW523();  
    }  
}  

运行程序，输出：

　　这是最原始的方式，客户需要知道如何去制造宝马车，客户和宝马车紧密耦合在了一起。为了降低耦合，我们引入工厂类，将制造宝马车的工作交给工厂去完成。
　　

简单工厂模式（Simple Factory）

　　创建一个制造宝马车的工厂类，其中有一个makeBMW方法用于根据获取的型号参数制造不同型号的宝马车：
　　
不同型号的宝马车:

public abstract class BMW {
}

public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("BMW320 has been made.");
    }
}

public class BMW523 extends BMW {
    public BMW523() {
        System.out.println("BMW523 has been made.");
    }
}

工厂类：

public class SimpleFactory {
    public BMW makeBMW(int type) {
        switch (type) {
        case 320:
            return new BMW320();
        case 523:
            return new BMW523();
        default:
            break;
        }
        return null;
    }

}

客户通过调用工厂中的方法获取宝马车：

public class Customer {  
    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        BMW bmw320 = simpleFactory.makeBMW(320);
        BMW bmw523 = simpleFactory.makeBMW(523);
    }  
}  

运行程序：

　　简单工厂模式又称静态工厂方法模式。它存在的目的很简单：定义一个用于创建对象的接口。
　　先来看看它的组成：
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在Java中由一个具体类实现。

　　简单工厂模式的工厂部分并不符合开闭原则（对扩展开放，对修改封闭），因为如果要增加一种新型宝马车，就需要修改工厂类的业务逻辑，例如现在要添加BMW545型，则需要先创建一个BMW545类继承自BMW类（这是符合开闭原则的），然后将工厂类改为下面的样子，这显然违背了开闭原则：

public class SimpleFactory {
    public BMW makeBMW(int type) {
        switch (type) {
        case 320:
            return new BMW320();
        case 523:
            return new BMW523();
        case 545:
            return new BMW545();
        default:
            break;
        }
        return null;
    }

}

工厂方法模式（Factory Method）

　　为了解决简单工厂模式的问题，工厂方法模式就诞生了，工厂方法模式将基类工厂定义为接口，然后定义各种不同类型的工厂用以生产不同类型的宝马车：
不同型号的宝马车:

public abstract class BMW {
}

public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("BMW320 has been made.");
    }
}

public class BMW523 extends BMW {
    public BMW523() {
        System.out.println("BMW523 has been made.");
    }
}

工厂类：

public interface IFactory {
    public abstract BMW makeBMW();
}

public class BMW320Factory implements IFactory {

    @Override
    public BMW makeBMW() {
        return new BMW320();
    }

}

public class BMW523Factory implements IFactory {

    @Override
    public BMW makeBMW() {
        return new BMW523();
    }

}

客户通过获取不同类型的工厂来获取不同型号的宝马车：

public class Customer {  
    public static void main(String[] args) {
        IFactory bmw320Factory = new BMW320Factory();
        BMW bmw320 = bmw320Factory.makeBMW();
        IFactory bmw523Factory = new BMW523Factory();
        BMW bmw523 = bmw523Factory.makeBMW();
    }  
}  

运行程序：

　　在工厂方法模式中，如果我们需要新增一款车型BMW545，那么只需要再新建一个IFactory接口的实现类：

public class BMW545Factory implements IFactory {

    @Override
    public BMW makeBMW() {
        return new BMW545();
    }

}

　　然后客户通过这个工厂即可得到BMW545型号的宝马车：

public class Customer {  
    public static void main(String[] args) {
        IFactory bmw545Factory = new BMW545Factory();
        BMW bmw545 = bmw545Factory.makeBMW();
    }  
}  

由于没有修改我们已有的代码，所以这是符合开闭原则的。
　　工厂方法模式仿佛已经很完美的对对象的创建进行了包装，客户仅需要定义相应产品的工厂实现类，就可以获取到某一型号的产品。但是，当产品种类非常多时，我们需要创建大量与之对应的工厂对象，这也不是我们所希望的。