工厂模式（Factory Pattern）

一，工厂模式：

就是建立一个工厂类，对实现了统一接口的一些类进行实例的创建，凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂模式进行创建。工厂模式代替了new创建对象的方式，是使用工厂来对对象进行统一管理的一种编程思想，使用工厂模式的好处就在于使得程序的可扩展性得到提高，降低了程序中类之间的依赖性和耦合性。下面以汽车和汽车的具体子类为例来说明工厂模式，并提供几种实现的方式。

---

二，工厂模式的几种实现方式

1，简单静态工厂
首先定义汽车接口Car

//定义汽车接口
interface Car
{
    //定义汽车跑的方法
    public abstract void run();
}

然后定义汽车的具体实现类，并实现接口中的抽象方法

//实现接口Car,定义汽车具体实现类---福特汽车
class Ford implements Car
{
    @Override
    public void run() 
    {
        System.out.println(this.getClass().getName()+"----Ford now is running.........");
    }
}
//实现接口Car,定义汽车具体实现类---吉普汽车
class Jeep implements Car
{
    @Override
    public void run() 
    {
        System.out.println(this.getClass().getName()+"----Jeep now is running.........");
    }
}
//实现接口Car,定义汽车具体实现类---林肯汽车
class Lincoln implements Car
{
    @Override
    public void run() 
    {
        System.out.println(this.getClass().getName()+"----Lincoln now is running.........");
    }
}

接着我们定义了一个汽车工厂，提供汽车的实例对象

//定义汽车工厂,简单静态工厂
class CarFactoryA
{
    //通过传递汽车的名称创建汽车
    public static Car createCar(String carName)
    {
        String car = carName.trim();
        if(car == null || car == ""){
            return null;
        }
        if(car == "Ford"){
            return new Ford();
        }else if(car == "Jeep"){
            return new Jeep();
        }else if (car == "Lincoln"){
            return new Lincoln();
        }else {
            return null;
        }
    }
}

最后编写了一个方法，对工厂进行测试

public static void testCarFactoryA(String carName)
{
    Car myCar = CarFactoryA.createCar(carName);
    myCar.run();
}

在main方法中调用

public static void main(String[] args) 
    {
        testCarFactoryA("Ford");
        testCarFactoryA("Jeep");
        testCarFactoryA("Lincoln");
    }

测试结果

designpattern.Ford----Ford now is running.........
designpattern.Jeep----Jeep now is running.........
designpattern.Lincoln----Lincoln now is running.........

这样我们就是实现了一个简单的静态工厂
优点：这个静态工厂的好处在于方法public static Car createCar(String carName)是静态的可以直接类名调用，获得对应的对象，最大的好处是，通过这个工厂我们可以获得不同的实例对象，只要是你实现了Car这个接口，具有一定的扩展性。
缺点：扩展性不强，比如日后要是再生产奥迪汽车的话，除了要写实现Car接口的Audi类，并且还要在工厂的createCar方法中增加if语句进行判断，对工厂类代码有修改。
2，java反射和泛型实现工厂
接口Car及其实现类同上，只修改工厂的代码

//java反射和泛型实现的工厂类
class CarFactoryB
{
    //泛型方法，T的类型是任何Car的子类
    public static <T extends Car> T createCar(Class<T> carName)throws Exception
    {
        T car = null;
        try {
            //利用反射创建实例
            car = (T) Class.forName(carName.getName()).newInstance();
        } catch (ClassNotFoundException e)
        {
            System.out.println("你要创建的实例："+carName+"不存在");
            throw new RuntimeException(e);
        }
        return car;
    }
}

测试方法

public static void testCarFactoryB()
    {
        Car myCar;
        try {
            myCar = CarFactoryB.createCar(Ford.class);
            myCar.run();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

调用及结果

public static void main(String[] args) 
    {
        testCarFactoryB();
    }

designpattern.Ford----Ford now is running.........

利用反射和泛型特性，这样我们就实现了较完整的一个工厂
优点：如果日后我们再想生产奥迪汽车的话，我们只需要编写Audi类就可以了，而不必再改动工厂CarFactoryB中的方法，程序可扩展性得到了极大增强，并且泛型帮助我们在调用CarFactoryB的createCar方法时，不必再进行强制类型转换，已在方法内部解决了，而CarFactoryA是需要在调用这个方法，返回对象时进行类型转换的。
缺点：反射方式创建对象的效率低，并且反射创建实例时调用的是无参的构造方法，这样一来，如果我们希望创建对象时做一些初始话操作或者使用有参构造方法的话，就显得无能为力了。

三，总结

综合上面的两种实现工厂模式的方式来看，方式二是对方式一的改进，方式二从可扩展性来看，明显强于方式一，所以笔者这里建议使用方式二。

参考链接：
http://blog.csdn.net/zxt0601/article/details/52798423
http://www.runoob.com/design-pattern/factory-pattern.html