工廠模式：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();
    }
}