设计模式之禅--2.工厂模式

工厂方法模式定义

Define an interface for creating an object,but let subclasses decide which class toinstantiate.Factory Method lets a class defer instantiation to subclasses.（定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。）

工厂方法模式的通用类图

演示代码

相传人类是女娲用泥捏成经过阴阳炉炼制而成，我们就模拟这一过程。首先定义人类Human接口

public interface Human {
	//不同的人有不同的颜色
	public void getcolor();
	//不同的人会说不同的语言
	public void talk();
}

 定义不同肤色的人种，实现Human的接口。首先是白人（估计是女娲没有掌握好火候炉火不够，哈哈哈）

public class WhiteHuman implements Human {

	@Override
	public void getcolor() {
		System.out.println("白色人种的皮肤颜色是白色的！");
	}

	@Override
	public void talk() {
		System.out.println("白色人种会说话，一般都是但是单字节。");
	}

}

之后是黑人 还是女娲没有掌握好火候炉火过了，哈哈哈。。

public class BlackHuman implements Human {

	@Override
	public void getcolor() {
		System.out.println("黑色人种的皮肤颜色是黑色的！");

	}

	@Override
	public void talk() {
		System.out.println("黑人会说话，一般人听不懂。");

	}

}

 最后是黄种人，火候刚刚好。。。

public class YellowHuamn implements Human {

	@Override
	public void getcolor() {
		System.out.println("黄色人种的皮肤颜色是黄色的！");
	}

	@Override
	public void talk() {
		System.out.println("黄色人种会说话，一般说的都是双字节。");

	}

}

制作人类的方法和技术都有了，还差个阴阳炉。我们就抽象一个。

public abstract class AbstractHumanFactory {
	public abstract <T extends Human> T createHuamn(Class<T> c);
}

 大家注意了，现在女娲开始造人了

public class NVWa {

	public static void main(String[] args) {
		// 声明阴阳八卦炉
		AbstractHumanFactory YinYangLu = new HumanFactory();

		// 女娲第一次造人，火候不足，缺陷产品
		System.out.println("--造出的第三批人是白色人种--");
		Human whiteHuman = YinYangLu.createHuamn(WhiteHuman.class);
		whiteHuman.getcolor();
		whiteHuman.talk();

		// 女娲第二次造人，火候过足，又是次品，
		System.out.println("\n--造出的第三批人是黑色人种--");
		Human blackHuman = YinYangLu.createHuamn(BlackHuman.class);
		blackHuman.getcolor();
		blackHuman.talk();

		// 第三次造人，火候正正好，优品！黄色人种
		System.out.println("\n--造出的第三批人是黄色人种--");
		Human yellowHuman = YinYangLu.createHuamn(YellowHuamn.class);
		yellowHuman.getcolor();
		yellowHuman.talk();

	}

}

现在我们看看阴阳炉的结果

 --造出的第三批人是白色人种--
白色人种的皮肤颜色是白色的！
白色人种会说话，一般都是但是单字节。

--造出的第三批人是黑色人种--
黑色人种的皮肤颜色是黑色的！
黑人会说话，一般人听不懂。

--造出的第三批人是黄色人种--
黄色人种的皮肤颜色是黄色的！
黄色人种会说话，一般说的都是双字节。
 

需求升级了 

经过艰苦卓绝的造人工程，女娲已经累得体力不支，他想能不能加快造人的速度？？于是改造了原有的方案。

1. 保持三种人种的制造方法，改造抽象造人工厂。

public abstract class AbstractHumanFactory {
//工厂一定能造人，不管是那种人

	public abstract Human createHuman();
	
}

2.一个工厂造人的速度太慢，我们建设三个工厂 （分别是WhiteHumanFactory，BlackHumanFactory，YellowHumanFactory）

 

public class WhiteHumanFactory extends AbstractHumanFactory {

	public Human createHuman() {
		return new YellowHuman();
	}
}

public class BlackHumanFactory extends AbstractHumanFactory {

	public Human createHuman() {
		return new BlackHuman();
	}
}

public class YellowHumanFactory extends AbstractHumanFactory {

	public Human createHuman() {
		return new WhiteHuman();
	}
}

 现在女娲可以轻松的休息了，我们的3个工厂开足马力生产，这样效率高了不少。

public class NvWa {

	public static void main(String[] args) {
		
		//女娲第一次造人，火候不足，缺陷产品
		System.out.println("--造出的第三批人是白色人种--");
		Human whiteHuman = (new WhiteHumanFactory()).createHuman();
		whiteHuman.getColor();
		whiteHuman.talk();
		
		//女娲第二次造人，火候过足，又是次品，
		System.out.println("\n--造出的第三批人是黑色人种--");
		Human blackHuman = (new BlackHumanFactory()).createHuman();
		blackHuman.getColor();
		blackHuman.talk();
		
		//第三次造人，火候正正好，优品！黄色人种
		System.out.println("\n--造出的第三批人是黄色人种--");
		Human yellowHuman = (new YellowHumanFactory()).createHuman();
		yellowHuman.getColor();
		yellowHuman.talk();
			
	}

}

 我们看看今天的造人计划成果，嗯就是快了不少。。。。。

--造出的第三批人是白色人种--
黄色人种的皮肤颜色是黄色的！
黄色人种会说话，一般说的都是双字节。

--造出的第三批人是黑色人种--
黑色人种的皮肤颜色是黑色的！
黑人会说话，一般人听不懂。

--造出的第三批人是黄色人种--
白色人种的皮肤颜色是白色的！
白色人种会说话，一般都是但是单字节。
 

 模版代码

设置自己所要生产的对象接口 

public interface Product {
	// 产品类的公共方法
	public abstract void method1();
	// 抽象方法1
	public abstract void method2();
}

声明具体的生产的产品

public class ConcreteProduct2 implements Product {

	@Override
	public void method1() {
		// TODO Auto-generated method stub

	}

	@Override
	public void method2() {
		// TODO Auto-generated method stub

	}

}

抽象出具体的生产工厂

public abstract class Create {
	public abstract <T extends Product> T createProduct(Class<T> c);
}

 实现具体的抽象工程

public class ConcreteCreator extends Create {

	@Override
	public <T extends Product> T createProduct(Class<T> c) {
		Product product=null;
		try {
			product=(Product)Class.forName(c.getName()).newInstance();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return (T)product;
	}

}

 测试一下

public class Client {

	public static void main(String[] args) {
		ConcreteCreator concreteCreator = new ConcreteCreator();
		ConcreteProduct1 createProduct = concreteCreator.createProduct(ConcreteProduct1.class);
		/*
		 * 继续业务处理
		 */
	}

}

工厂方法模式的优点

首先，良好的封装性，代码结构清晰。一个对象创建是有条件约束的，如一个调用者需
要一个具体的产品对象，只要知道这个产品的类名（或约束字符串）就可以了，不用知道创
建对象的艰辛过程，降低模块间的耦合。
其次，工厂方法模式的扩展性非常优秀。在增加产品类的情况下，只要适当地修改具体
的工厂类或扩展一个工厂类，就可以完成“拥抱变化”。例如在我们的例子中，需要增加一个
棕色人种，则只需要增加一个BrownHuman类，工厂类不用任何修改就可完成系统扩展。
再次，屏蔽产品类。这一特点非常重要，产品类的实现如何变化，调用者都不需要关
心，它只需要关心产品的接口，只要接口保持不变，系统中的上层模块就不要发生变化。因
为产品类的实例化工作是由工厂类负责的，一个产品对象具体由哪一个产品生成是由工厂类
决定的。在数据库开发中，大家应该能够深刻体会到工厂方法模式的好处：如果使用JDBC
连接数据库，数据库从MySQL切换到Oracle，需要改动的地方就是切换一下驱动名称（前提
条件是SQL语句是标准语句），其他的都不需要修改，这是工厂方法模式灵活性的一个直接
案例。
最后，工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类，其他的实
现类都不用关心，符合迪米特法则，我不需要的就不要去交流；也符合依赖倒置原则，只依
赖产品类的抽象；当然也符合里氏替换原则，使用产品子类替换产品父类，没问题！