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 createHuamn(Class 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 createProduct(Class c);
}
实现具体的抽象工程
public class ConcreteCreator extends Create {
@Override
public T createProduct(Class 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语句是标准语句),其他的都不需要修改,这是工厂方法模式灵活性的一个直接
案例。
最后,工厂方法模式是典型的解耦框架。高层模块值需要知道产品的抽象类,其他的实
现类都不用关心,符合迪米特法则,我不需要的就不要去交流;也符合依赖倒置原则,只依
赖产品类的抽象;当然也符合里氏替换原则,使用产品子类替换产品父类,没问题!