设计模式之工厂模式

一。简单工厂模式：

理解了以下两个例子，再来看第三个例子：
注意对比以下三个实例的不同
实例１：

package org.jzkangta.factorydemo01;
//定义接口
interface Car{
    public void run();
    public void stop();
}
//具体实现类
class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}
//具体实现类
class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}
//工厂
class Factory{
    public static Car getCarInstance(){
        return new Ford();
    }
}
public class FactoryDemo01 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance();
        c.run();
        c.stop();

    }

}

实例二：

package fac;


//定义接口
interface Car{
    public void run();
    public void stop();
}
//具体实现类
class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}
//工厂
class Factory{
    public static Car getCarInstance(String type){
        Car c=null;
        if("Benz".equals(type)){
            c=new Benz();
        }
        if("Ford".equals(type)){
            c=new Ford();
        }
        return c;
    }
}


public class FactoryDemo02 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance("Benz");
        if(c!=null){
            c.run();
            c.stop();
        }else{
            System.out.println("造不了这种汽车。。。");
        }
        

    }

}

实例三：

interface Car{
    public void run();
    public void stop();
}

class Benz implements Car{
    public void run(){
        System.out.println("Benz开始启动了。。。。。");
    }
    public void stop(){
        System.out.println("Benz停车了。。。。。");
    }
}

class Ford implements Car{
    public void run(){
        System.out.println("Ford开始启动了。。。");
    }
    public void stop(){
        System.out.println("Ford停车了。。。。");
    }
}

class Toyota implements Car{
    public void run(){
        System.out.println("Toyota开始启动了。。。");
    }
    public void stop(){
        System.out.println("Toyota停车了。。。。");
    }
}

class Factory{
    public static Car getCarInstance(String type){
        Car c=null;
        try {
            c=(Car)Class.forName("org.jzkangta.factorydemo03."+type).newInstance();//利用反射得到汽车类型　
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    
        return c;
    }
}
public class FactoryDemo03 {

    public static void main(String[] args) {
        Car c=Factory.getCarInstance("Toyota");
        if(c!=null){
            c.run();
            c.stop();
        }else{
            System.out.println("造不了这种汽车。。。");
        }
        

    }

}

对比三个实例：

实例一，虽然实现了简单工厂，但每次只能得到一种汽车，如果我们想换一种，就得修改工厂，太不方便，而实例二则改变了这种情况，便得我们可以按照我们的需要更换汽车，但我们所更换的汽车必须是实现类中有的，如果我们想要增加一种汽车的时候，我们还是得更改工厂，通过改进，实例三利用反射机制，得到汽车类型，这样当我们需要增加一种新的汽车时，就无需要再修改工厂，而只需要增加要实现的类即可。也就是说要增加什么样的汽车直接增加这个汽车的类即可，而无需改变工厂。从而达到了工厂分离的效果。 

二.工厂方法模式

（和简单工厂模式的区别，工厂方法模式是在简单工厂模式的基础上进行再抽象，将工厂细分，细分出抽象工厂角色和具体工厂角色，）

和简单工厂对比优缺点：

1.

工厂方法模式是对工厂的抽象，即提供一个抽象的工厂角色，提供给具体的工厂角色需要实现的功能。

调用具体工厂角色的方法有两种，

1.用户知道需要哪个具体的工厂角色，直接调用具体的工厂角色。

2.用反射实现的工厂方法模式。

第一种和第二种都有相同的角色

如下：

/**
 * 抽象产品
 * @author zhengdong.xiao
 */
public interface Car {
public void drive();
}

/**
 * 具体产品
 * @author zhengdong.xiao
 */
public class BenzCar implements Car {
@Override
public void drive() {
System.out.println("benz drive!");
}
}

/**
 * 具体产品
 * @author zhengdong.xiao
 */
public class BWMCar implements Car {
@Override
public void drive() {
System.out.println("bmw drive!");
}
}

/**
 * 抽象汽车工厂
 * @author zhengdong.xiao
 */
public interface CarFactory {
public Car createCar();
}

/**
 * 具体产品工厂
 * @author zhengdong.xiao
 */
public class BMWCarFactory implements CarFactory {
@Override
public Car createCar() {
return new BWMCar();
}
}

/**
 * 具体产品工厂
 * @author zhengdong.xiao
 */
public class BenzCarFactory implements CarFactory {
@Override
public Car createCar() {
return new BenzCar();
}
}

/**
 * 工厂方法测试
 * @author zhengdong.xiao
 */
public class TestFactoryFunction {
private  static String BWMCar="BMWCarFactory";
private  static String BenzCar="BenzCarFactory";
public static void main(String[] args) throws Exception{
// CarDriven carDriven=new CarDriven();
// carDriven.getcar(TestFactoryFunction.BenzCar).drive();
// carDriven.getcar(TestFactoryFunction.BWMCar).drive();
Car car=new BenzCarFactory().createCar();
car.drive();
Car car1=new BMWCarFactory().createCar();
car1.drive();
}
}

第二种：用反射形式实现，除了测试所有对象都用以上对象。新加入用于获取car的对象。

/**
 * 汽车驱动类
 * @author zhengdong.xiao
 */
public class CarDriven {
/**
* 通过厂商得到车
*/
public Car getcar(String factoryName) throws Exception{
CarFactory carFactory=(CarFactory)Class.forName("org.guili.test.service.factoryfunction."+factoryName).newInstance();
return carFactory.createCar();
}
}

/**
 * 工厂方法测试
 * @author zhengdong.xiao
 */
public class TestFactoryFunction {
private  static String BWMCar="BMWCarFactory";
private  static String BenzCar="BenzCarFactory";
public static void main(String[] args) throws Exception{
CarDriven carDriven=new CarDriven();
carDriven.getcar(TestFactoryFunction.BenzCar).drive();
carDriven.getcar(TestFactoryFunction.BWMCar).drive();
}
}