工厂模式：Java和C++的实现

工厂模式的大概思路是，有几个处于同一个范畴的子类，为了生成这几个类具体对象，我们可以创建一个工厂类，只要给这个工厂一个类型，这个工厂就会返回我们要的具体的类的实例。讲的不是很清楚，我们看一个例子。

出行的需要交通工具，比如汽车，飞机。这些具体的交通工具就是一个个子类，而且可以通过票价，速度，运行方式三个方面来描述。而这些子类的父类可以抽象成一个叫交通工具的接口。（在JAVA里就是Interface，C++就是一个抽象类）。

之后我们可以创建一个工厂类。当我们给这个工厂类一个参数，相当于给工厂发了一个需求，工厂按需给我们上交货物，就是按照类型子类的实例。具体的类图如下。

Car和CPlane就是我们的子类，IVehicle（交通工具）就是抽象出来的接口，Factory就是工厂类

接口在IVehicle.h实现

#pragma once
#include<iostream>
class IVehicle {
public:
	virtual void TicketCost() = 0;
	virtual void WorkWay() = 0;
	virtual void Speed() = 0;
	

};

类Car在car.h实现

#pragma once
#include"IVehicle.h"
class Car :public IVehicle {
public:
	void TicketCost() {
		std::cout << "Car Ticket cheap" << std::endl;

	}
	void WorkWay() {
		std::cout << "Car run on land" << std::endl;
	}
	void Speed() {
		std::cout << "Car not fast" << std::endl;
	}
};

 类CPlane在 Plane.h 实现

#pragma once
#pragma once
#include"IVehicle.h"
class CPlane :public IVehicle {
public:
	void TicketCost() {
		std::cout << "Plane Ticket expensive" << std::endl;

	}
	void WorkWay() {
		std::cout << "Plane run on land" << std::endl;
	}
	void Speed() {
		std::cout << "Plane not fast" << std::endl;
	}
};

工厂在Factory.h实现

#include"IVehicle.h"
#include"car.h"
#include"Plane.h"
#pragma once
class CFactory {
public:
	IVehicle* CreateVehicle(int type)
	{
		switch (type)
		{
		case 1:
			return new Car();
		case 2:
			return new CPlane();
		default:
			break;
		}
	}
};

最后来看看调用

// FactoryPattern.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include"Factory.h"


int main()
{
	CFactory * Factory = new CFactory();
	IVehicle *Vehicle = Factory->CreateVehicle(2);
	Vehicle->TicketCost();
	Vehicle->Speed();
	Vehicle->WorkWay();
    return 0;
}

基于同样的思路，我们看看在JAVA里怎么实现，只有在两种语言都实现了，才有可能真正理解。

接口的实现

package com.yangchao.Factory;

public interface IVehicle {
    public void TicketCost();
    public void WorkWay();
    public void Speed();
}

两个子类的实现

Plane

package com.yangchao.Factory;

public class Plane implements IVehicle {
    @Override
    public void TicketCost() {
        System.out.println("Buy Plane ticket");
    }

    @Override
    public void WorkWay() {
        System.out.println("Plane Fly in the sky");

    }

    @Override
    public void Speed() {
        System.out.println("Plane so Fast");

    }
}

Car

package com.yangchao.Factory;

public class Car implements IVehicle {
    @Override
    public void TicketCost() {
        System.out.println("Buy car ticket");

    }

    @Override
    public void WorkWay() {
        System.out.println("Car Run on land");

    }

    @Override
    public void Speed() {
        System.out.println("Car not fast");

    }
}

工厂类接受的参数是具体的类的名称，不像C++里我们自定义的参数。因为JAVA反射机制的存在，可以直接根据传递的类的名称创建类的实例。

package com.yangchao.Factory;

public class Factory {
    public static IVehicle CreateVehicle(Class c){
        IVehicle Vehicle =null;
        try{
            Vehicle = (IVehicle)Class.forName(c.getName()).newInstance();
        }
        catch(IllegalAccessException e){
            System.out.println("IllegalAccessException");
        }
        catch(InstantiationException e)
        {
            System.out.println("InstantiationException");
        }
        catch(ClassNotFoundException e)
        {
            System.out.println("ClassNotFoundException");
        }
        return Vehicle;
    }
}

最后看看Java里是怎么调用的

package com.yangchao.Factory;

public class Test {
    public static void main(String[] args){
        System.out.println("welcome to factory!!!!!!");
        IVehicle car =Factory.CreateVehicle(Car.class);
        car.TicketCost();
        car.Speed();
        car.WorkWay();
    }
}