Java设计模式——工厂方法和抽象工厂方法

工厂方法(Factory Method)模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂 角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

例如：

//交通工具必须实现的接口
public interface Moveable {
public void run();
}

//交通工具1.car
public class Car implements Moveable{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Car----------------");

}

}

//交通工具2.plane
public class Plane implements Moveable{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Plane----------------");
}

}

//作为工厂必须实现的接口
public interface Factory {
public Moveable create();
}

//具体的交通工具工厂CarFactory
public class CarFactory implements Factory{

@Override
public Moveable create() {
// TODO Auto-generated method stub

return new Car();
}

}

//具体的交通工具工厂PlaneFactory
public class PlaneFactory implements Factory{

@Override
public Moveable create() {
// TODO Auto-generated method stub
return new Plane();
}

}

测试1：

public class Test {
public static void main(String args[]){
Factory fac = new PlaneFactory();
Moveable mov = fac.create();
mov.run();
}
}

输出1：

Plane----------------

测试2:

public class Test {
public static void main(String args[]){
Factory fac = new CarFactory();
Moveable mov = fac.create();
mov.run();
}
}

输出2：

Car----------------

在上述例子中，工厂方法使我们能够定制任意交通工具的类型和生产过程，假设我们有了新的交通工具vihicle

//交通工具3.vihicle
public class Vihicle implements Moveable{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Vihicle----------------");
}
}

实现VihicleFactory类：

public class VihicleFactory implements Factory{

@Override
public Moveable create() {
// TODO Auto-generated method stub
return new Vihicle();
}

}

在生产过程中，我们只需new一个VihicleFactory并调用create()方法即可：

public class Test {
public static void main(String args[]){
Factory fac = new VihicleFactory();
Moveable mov = fac.create();
mov.run();
}
}

输出：

Vihicle----------------

在工厂方法中，每当我们有了新的Product需要生产时，我们就必须实现对应的ProductFactory，这样一来，随着Product数量的增多，往往容易造成ProductFactory泛滥，若我们想要生产十几种产品就要相应的实现十几个具体的工厂，这显然是不科学的，而抽象工厂方法正好解决了这个问题

例：

//食物接口
public interface Food {
public void printName();
}

//食物产品1.apple
public class Apple implements Food{

@Override
public void printName() {
// TODO Auto-generated method stub
System.out.println("this is apple");
}

}

//食物产品2.banana
public class Banana implements Food{

@Override
public void printName() {
// TODO Auto-generated method stub
System.out.println("this is banana");
}

}

//汽车接口
public interface Vehicle {
public void run();
}

//汽车产品1.benz
public class Benz implements Vehicle{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("Benz--------------");
}

}

//汽车产品2.bwm
public class BWM implements Vehicle{

@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("BWM--------------");
}

}

//武器接口
public interface Weapon {
public void shot();
}

//武器产品1.AK47
public class AK47 implements Weapon{
@Override
public void shot(){
System.out.println("AK47-------------");
}
}

//武器产品2.M4
public class M4 implements Weapon{

@Override
public void shot() {
// TODO Auto-generated method stub
System.out.println("M4--------------");
}

}

//工厂接口
public interface AbstractFactory {
public Vehicle createVehicle();
public Weapon  createWeapon();
public Food     createFood();
}

//工厂1：能够生产BWM、AK47、Apple
public class Factory1 implements AbstractFactory{

@Override
public Vehicle createVehicle() {
// TODO Auto-generated method stub
return new BWM();
}

@Override
public Weapon createWeapon() {
// TODO Auto-generated method stub
return new AK47();
}

@Override
public Food createFood() {
// TODO Auto-generated method stub
return new Apple();
}

}

//工厂2：Benz、M4、Banana
public class Factory2 implements AbstractFactory{

@Override
public Vehicle createVehicle() {
// TODO Auto-generated method stub
return new Benz();
}

@Override
public Weapon createWeapon() {
// TODO Auto-generated method stub
return new M4();
}

@Override
public Food createFood() {
// TODO Auto-generated method stub
return new Banana();
}

}

测试1：

public class Test {
public static void main(String args[]){
AbstractFactory abs=new Factory1();
Food fo = abs.createFood();
Vehicle ve = abs.createVehicle();
Weapon we = abs.createWeapon();
fo.printName();
ve.run();
we.shot();
}
}

输出1：

this is apple
BWM--------------
AK47-------------

测试2:

public class Test {
public static void main(String args[]){
AbstractFactory abs=new Factory2();
Food fo = abs.createFood();
Vehicle ve = abs.createVehicle();
Weapon we = abs.createWeapon();
fo.printName();
ve.run();
we.shot();
}
}

输出2:

this is banana
Benz--------------
M4--------------

抽象工厂的优点在于能够生产一系列可能存在关联的产品，但是，当我们需要在抽象工厂中添加新的产品时，几乎所有的工厂类都要修改



图片来自http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html



图片来自http://www.cnblogs.com/devinzhang/archive/2011/12/19/2293160.html

这样看来：

工厂模式生产一类产品（一个产品等级结构），来自同一个接口或抽象类

抽象工厂生产多类可能存在关联的产品（多个产品等级结构），来自多个接口或抽象类