第六篇:工厂模式

说到工厂模式，根据实现方式和运用场景的不同，我们一般将它归纳为三种工厂，普通工厂模式，静态工厂模式以及工厂方法模式；今天我们就分别说说这几种模式的实现以及它们之间的区别；

写代码之前我们先来谈谈工厂模式的作用？

很简单，就像我们现实中的工厂一样，现在你需要一部手机，如果让你自己去制作，那么你需要知道一部手机的整个制作流程，你有兴趣去关心手机怎么制作出来的吗？拜托，你只是想要一部手机而已！但如果有这么一个对象(工厂) ， 你只要告诉它，我要一部什么牌子的手机，它就能给你制作出来，你完全不需要去理会整个制作流程的复杂性，这该由多好啊！写到这里，聪明的你应该已经懂了，没错，工厂模式就是开辟一个工厂对象，它帮我们创造各种我们需要的对象！

那我们今天的例子就以手机制作来举例吧！

/**手机父对象*/
public class Phone {
	protected String brand ; //手机品牌
	protected String color; //手机颜色
	protected String size ; //手机尺寸
	
	//一堆set get 方法...
	public String getBrand() {return brand;}
	public void setBrand(String brand) {this.brand = brand;}
	public String getColor() {return color;}
	public void setColor(String color) {this.color = color;}
	public String getSize() {return size;}
	public void setSize(String size) {this.size = size;}
	
	protected void show() {
		System.out.println("我是有着"+this.color+"颜色，"+this.size+"的"+this.brand+"手机");
	}
	
	
}

/**苹果一代*/
class AppleOne extends Phone{
	public AppleOne() {
		this.brand = "苹果1代";
		this.color = "玫瑰金";
		this.size = "6.0英寸";
	}
}

/**苹果二代*/
class AppleTwo extends Phone{
	public AppleTwo() {
		this.brand = "苹果2代";
		this.color = "绿色";
		this.size = "6.0英寸";
	}
}

看看如果不用工厂生产手机会怎样：

/**手机商店*/
public class PhoneStore {
	
	/**购买手机
	 * @param brand 手机品牌
	 * */
	public Phone buy( String brand){
		Phone phone = null;
		if( "apple_one".equals(brand) ){//为客户生产一代苹果手机
			//生产出一代苹果手机，需要对手机对象再做N多工序...
			phone = new AppleOne();
			//phone.打磨()
			//phone.零件组装()
			//phone.质量检测()
		}else if( "apple_two".equals(brand) ){
			phone = new AppleTwo();
		}else if( "xxx".equals(brand)){
			//...
		}
		return phone;
	}
}

这里我们有一个手机商店，客户通过buy方法购买手机，现在，由我们的手机商店来亲自生产手机...这明显是不合理的， 面向对象原则中的一点，单一职责原则:一个对象应该只做它范围内的事！商店应该从手机工厂拿到手机，再来进行贩卖，由于客户的要求它可以在贩卖时为手机装保护壳，这是它的职责，但它无论如何都不应该去制作手机，它也不知道该怎么去做，正如注释上写的，手机需要打磨...组装零件...等等等等，这些步骤只有手机制造工厂才知道怎么完成！

我们来将上面的代码稍微进行一下修改吧！

一：普通工厂模式；

/**苹果手机制造工厂*/
public class AppleFactory {
	
	//我们将PhoneStore的buy中的代码搬到了这里！
	public Phone createPhone( String brand){
		Phone phone = null;
		if( "apple_one".equals(brand) ){//为客户生产一代苹果手机
			//生产出一代苹果手机，需要对手机对象再做N多工序...
			phone = new AppleOne();
			//phone.打磨()
			//phone.零件组装()
			//phone.质量检测()
		}else if( "apple_two".equals(brand) ){
			phone = new AppleTwo();
		}else if( "xxx".equals(brand)){
			//...
		}
		return phone;
	}
}

然后对PhoneStore类稍作修改：

/**手机商店*/
public class PhoneStore {
	
	/**购买手机
	 * @param brand 手机品牌
	 * */
	public Phone buy(String brand, AppleFactory appleFactory){
		Phone phone = appleFactory.createPhone(brand);
		//phone.加上手机套();
		return phone;
	}
}

好了，我们看看上面的代码，很简单对不对，将制作手机的任务交给手机工厂去做，而手机售卖店通过去客户端传递给它的工厂对象中拿到制作好的手机，AppleFactory这个类就是我们所谓的普通工厂啦！

所谓的普通工厂模式就是提供一个方法，用来产生我们需要的对象啦！这其实不算是个设计模式，我们正常的思维就应该是这样的！

二：静态工厂模式；

将上面的AppleFactory类的createPhone方法加上static修饰符，它就是个静态工厂了...区别就不用多说了，普通工厂依赖于工厂对象，而静态工厂由于是个静态方法，就不依赖与类啦！

三：工厂方法模式；

我们重点来说说这个模式，现在，请你思考一下，上面的代码中，手机商店只能出售苹果手机，而现在，我们店铺生意太好啦！为了增加营业额，想一并出售华为，魅族这几款手机，将来也还会有更多的品牌被引入进来，那么你怎么来修改你的代码设计呢？

/**定义一个手机抽象工厂*/
public abstract class AbstractPhoneFactory {
	
	/**创建手机的任务交给子类去做！*/
	public abstract Phone createPhone(String brand);
}

/**手机商店*/
public class PhoneStore {
	
	/**购买手机
	 * @param brand 手机品牌
	 * */
	//看下面注释掉的旧代码！这里写死了AppleFactory ，所以只能生产苹果手机，
	//那我们首先第一步就得要让这里依赖于抽象，好让我们能动态扩展！
	//public Phone buy(String brand, AppleFactory phoneFactory){
	
	//改下代码，让其依赖于抽象工厂AbstractPhoneFactory
	public Phone buy(String brand, AbstractPhoneFactory phoneFactory){
		Phone phone = phoneFactory.createPhone(brand);
		//phone.加上手机套();
		return phone;
	}
}

创造几个手机制造工厂和手机子类：

/**魅族 mx1*/
class MeizuOne extends Phone{
	public MeizuOne() {
		this.brand = "MX1";
		this.color = "白";
		this.size = "4.5英寸";
	}
}

/**魅族 mx2*/
class MeizuTwo extends Phone{
	public MeizuTwo() {
		this.brand = "MX2";
		this.color = "白";
		this.size = "5.5英寸";
	}
}

/**魅族制造工厂*/
class MeizuFactory extends AbstractPhoneFactory{
	
	public Phone createPhone( String brand){
		Phone phone = null;
		if( "meizu_one".equals(brand) ){
			phone = new MeizuOne();
		}else if( "meizu_Two".equals(brand) ){
			phone = new MeizuTwo();
		}
		return phone;
	}
}

/**华为制造工厂*/
//为节省代码量，就不写华为手机的实体以及下面的具体实现了...
class HuaweiFactory extends AbstractPhoneFactory{
	
	public Phone createPhone( String brand){
		Phone phone = null;
		if( "huawei_x1".equals(brand) ){
			//phone = new HuaweiX1();
		}else if( "huawei_x2".equals(brand) ){
			//phone = new HuaweiX2();
		}
		return phone;
	}
}

测试一下：

public class Test {
	
	public static void main(String[] args) {
		PhoneStore ps = new PhoneStore();
		AbstractPhoneFactory appleFactory = new AppleFactory();
		Phone appleOne = ps.buy("apple_one", appleFactory);
		appleOne.show();
		
		AbstractPhoneFactory meizuFactory = new MeizuFactory();
		Phone meizuOne = ps.buy("meizu_one", meizuFactory);
		meizuOne.show();
		
		Phone meizuOTwo = ps.buy("meizu_two", meizuFactory);
		meizuOTwo.show();
	}
}

输出：******************************************************************************

我是有着玫瑰金颜色，6.0英寸的苹果1代手机
我是有着白颜色，4.5英寸的MX1手机
我是有着白颜色，5.5英寸的MX2手机

******************************************************************************

现在我们的手机售卖店可以支撑各种手机的售卖啦！只要告诉它生产这种品牌手机的正确的工厂以及要生产的手机，它就直接去工厂获得手机，至于各种品牌的手机的制造差异，这就交给不同的工厂去实现吧！

最后我们来说下工厂方法模式的定义： 其实，工厂方法模式也称之为抽象工厂模式，工厂方法模式定义了一个抽象工厂类，它定义了一个生成对象的方法，至于怎么生成对象，交给实现它的具体子类去做，也就是说工厂方法模式将类的实例化推迟给子类

让我们看下类图吧！