工厂模式的大概思路是,有几个处于同一个范畴的子类,为了生成这几个类具体对象,我们可以创建一个工厂类,只要给这个工厂一个类型,这个工厂就会返回我们要的具体的类的实例。讲的不是很清楚,我们看一个例子。
出行的需要交通工具,比如汽车,飞机。这些具体的交通工具就是一个个子类,而且可以通过票价,速度,运行方式三个方面来描述。而这些子类的父类可以抽象成一个叫交通工具的接口。(在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();
}
}