【设计模式】工厂系列总结

以交通工具举例

一、静态工厂（不属于GOF 23)

给司机一辆车（也可以添加多态，让司机选一辆车）

	private static Car car = new Car();
	//private static List<Car> cars = new ArrayList<Car>();
	
	public Car(){}
	
	public static Car getInstance() {
		
		return car;
	}
	
	public void run() {
		System.out.println("冒着烟奔跑中car.......");
	}
}

二、工厂方法模式

概念：定义一个用于创建对象的接口，让子类决定实例化哪一个类，Factory Method使一个类的实例化延迟到了子类。

任意定制交通工具（多态）类型和生产过程

<span style="font-size:14px;">public interface Moveable {
	void run();
}
public class Car implements Moveable{
	public void run() {
		System.out.println("冒着烟奔跑中car.......");
	}
}
public class Plane implements Moveable {
	@Override
	public void run() {
		System.out.println("扇着翅膀前进中plane....");
	}
}</span>

<span style="font-size:14px;">public abstract class VehicleFactory {
	abstract Moveable create();
}
public class CarFactory extends VehicleFactory{
	public Moveable create() {
		return new Car();
	}
}
public class BroomFactory extends VehicleFactory{
	public Moveable create() {
		return new Broom();
	}
}</span>

public class Test {
	public static void main(String[] args) {
		VehicleFactory factory = new BroomFactory();
		Moveable m = factory.create();
		m.run();
	}
}

三、抽象工厂模式

概念：提供一个创建一系列相关或相互依赖对象的接口，而无须指定它们的具体类。与工厂方法不同在于抽象工厂创建一系列的多个产品。

控制系列产品（车，武器，食品补给）生产替换

添加产品类型，以及对应的产品

public abstract class Vehicle {
	public abstract void run();
}
public class Car extends Vehicle {
	public void run() {
		System.out.println("冒着烟奔跑中car.......");
	}
}
public class Broom  extends Vehicle{
	public void run() {
		System.out.println("一路沙尘暴飞奔而来broom.....");
	}
}

public abstract class Food {
	public abstract void printName();
}
public class Apple extends Food {
	public void printName() {
		System.out.println("apple");
	}
}
public class MushRoom extends Food {

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

}

public abstract class Weapon {
	public abstract void shoot();
}
public class AK47 extends Weapon{
	public void shoot() {
		System.out.println("哒哒哒...");
	}
}
public class MagicStick extends Weapon {
	@Override
	public void shoot() {
		System.out.println("fire hu hu hu ...");
	}
}

创建抽象工厂

public abstract class AbstractFactory {
	public abstract Vehicle createVehicle();
	public abstract Weapon createWeapon();
	public abstract Food createFood();
	
}

public class DefaultFactory extends AbstractFactory{//创建抽象工厂，定制生产一系列产品

	@Override
	public Food createFood() {
		return new Apple();
	}
	@Override
	public Vehicle createVehicle() {
		return new Car();
	}
	@Override
	public Weapon createWeapon() {

		return new AK47();
	}
}

public class MagicFactory extends AbstractFactory {//

	@Override
	public Food createFood() {
		return new MushRoom();
	}

	@Override
	public Vehicle createVehicle() {
		return new Broom();
	}

	@Override
	public Weapon createWeapon() {
		return new MagicStick();
	}
	
}

添加客户端代码：

public class Test {
	public static void main(String[] args) {
		//DefaultFactory f = new DefaultFactory();
		AbstractFactory f = new DefaultFactory();
		Vehicle v = f.createVehicle();
		v.run();
		Weapon w = f.createWeapon();
		w.shoot();
		Food a = f.createFood();
		a.printName();
	}
}

总结：工厂方法与抽象工厂最大的区别和各自的优缺点：

对于普通的工厂，可以在产品这个维度进行扩展，可以产生新的产品和新的产品的工厂，但是如果产生产品系列（一系列不同类产品的具体产品），会出现 工厂类泛滥的问题。抽象工厂解决这个问题，能产生新的产品系列。

而如果需要增加新的产品品种的话，这是需要修改抽象工厂接口增加新的方法，然后所有实现工厂增加新的方法。