设计模式之工厂模式（Factory）

工厂模式：简单的说是一种类的创建模式，适用于在创建多个复杂对象的时候（在不同情况下创建不同对象）

 工厂模式的形态
工厂模式主要用一下几种形态：
1.简单工厂（Simple Factory）：在工厂类定义创建不同对象实例的方法，在需要使用对象的地方，通过创建工厂并给出需要的对象名称来获取对象实例

2.抽象工厂（Abstract Factory）：工厂的工厂

简单工厂（Simple Factory）
又叫静态工厂，下面我们来看一个具体的例子：
假设一家汽车工厂，有生产BMW宝马汽车的， 有生产QQ汽车的
首先我们先为所有产品定义一个共同的汽车接口：

public interface Car {
	void run();
}

下面工厂生产的BMW和QQ 都必须实现这个接口

public class BMW implements Car{
	@Override
	public void run() {
		System.out.println("BMW在跑");
	}
}
public class QQ implements Car{
    @Override
    public void run() {
        System.out.println("QQ车在跑！");
   }
}

接下写一个工厂类，他主要负责生产以上的产品

public class FactoryCar {
	public Car getCar(String carName) {
		if(carName ==null){
			return null;
		}
		if("BMW".equals(carName)){
			return new BMW();
		}else if("QQ".equals(carName)){
			return new QQ();
		}
		return null;
	}
}

写一个测试类：

public class Test {
	public static void main(String[] args) {
		 FactoryCar fc = new FactoryCar();
		 Car car = fc.getCar("BMW");
		 car.run();
	}
}

console   输出 ：  BMW在跑

由上面的代码可以看出，简单工厂的核心就是一个 FactoryCar类，他拥有必要的逻辑判断能力和所有产品的创建权利，我们只需要向把定单给他，就能得到我们想要的产品。这使用起来似乎非常方便。
但，实际上，这个 FactoryCar有很多的局限。首先，我们每次想要增加一种新产品的时候，都必须修改 FactoryCar的原代码。其次，当我们拥有很多很多产品的时候，而且产品之间又存在复杂的层次关系的时候，这个类必须拥有复杂的逻辑判断能力，其代码量也将不断地激增，这对以后的维护简直就是恐怖两个字...
还有就是，整个系统都严重依赖 FactoryCar类，只要 FactoryCar类一出问题，系统就进入不能工作的状态，这也是最为致命的一点....
所以出现了抽象工厂

抽象工厂：意的意图在于创建一系列互相关联或互相依赖的对象。<<Java设计模式>>

工厂方法用来创建一个产品，它没有分类的概念，而抽象工厂则用于创建一系列产品，所以产品分类成了抽象工厂的重点，
我们继续用上面的例子来说明： 加上一个颜色类

public interface Colors { //定义一个颜色的接口
	void color();
}
public interface Car {  //定义一个汽车的接口
	void run();
}


颜色有红色类和绿色类

public class Blue implements Colors{
	@Override
	public void color() {
		System.out.println("蓝色的");
	}
}
public class Red implements Colors{
    @Override
    public void color() {
        System.out.println("红色的");
    }
}

抽象工厂

public abstract class AbstractFactory {
	
	abstract Car getCar(String carName);
	abstract Colors getColor(String colorName);
}
让汽车工厂和颜色工厂都继承抽象工厂

public class FactoryColor extends AbstractFactory{  //颜色工厂继承抽象工厂 重写getColor方法
	@Override
	Car getCar(String carName) {
		// TODO Auto-generated method stub
		return null;
	}
	@Override
	Colors getColor(String colorName) { 
		if (colorName == null) {
			return null;
		}
		if ("Red".equals(colorName)) {
			return new Red();
		} else if ("Blue".equals(colorName)) {
			return new Blue();
		}
		return null;
	}
}

public class FactoryCar extends AbstractFactory{//汽车工厂继承抽象工厂 重写getCar方法
    @Override
    Car getCar(String carName) {
        if(carName ==null){
            return null;
        }
        if("BMW".equals(carName)){
            return new BMW();
        }else if("QQ".equals(carName)){
            return new QQ();
        }
        return null;
    }
    @Override
    Colors getColor(String colorName) {
        // TODO Auto-generated method stub
        return null;
    }
}
编写   FactoryBuilder


public class FactoryBuilder {
	public static AbstractFactory getFactory(String FactoryName) {
		if (FactoryName == null) {
			return null;
		}
		if ("Car".equals(FactoryName)) {
			return new FactoryCar();
		} else if ("Colors".equals(FactoryName)) {
			return new FactoryColor();
		}
		return null;
	}
}
编写测试类
public class Test {
	public static void main(String[] args) {
		FactoryBuilder fb = new FactoryBuilder();
		AbstractFactory abf = fb.getFactory("Colors");
		abf.getColor("Red").color();
		abf = fb.getFactory("Car");
		abf.getCar("BMW").run();
	}
}

运行结果： 
 
红色的
BMW在跑


这样，抽象工厂就编写完成了。从上面可以看出，要先对创建的对象进行系统的分类，这点很重要，好的产品分类规则能为具体工厂类的选择调用和以后的扩展提供清晰的思路.