FactoryMethod:工厂方法模式
先代码
父类或接口类:
package h.ldemo.factorymethod;
/**
*
* @author: Is-Me-Hl
* @date: 2020年1月31日
* @Description: Demo--简单工厂模式
* SuperClassOrInterface:表示父类或者接口都行,此处两者代码都会给出,大同小异
*/
/*public abstract class SuperClassOrInterface {
// 抽象方法
public abstract void doSomeThings();
// 非抽象方法
public void doThings(){
System.out.println("SuperClassOrInterface:doThings...");
}
}*/
public interface SuperClassOrInterface{
public void doSomeThings();
}
子类或实现类(两个):
package h.ldemo.factorymethod;
/**
*
* @author: Is-Me-Hl
* @date: 2020年1月31日
* @Description: 子类1:继承或实现
*/
/*public class SubClassOrImplClass1 extends SuperClassOrInterface {
*//**
* 实现抽象方法
*//*
@Override
public void doSomeThings() {
// TODO Auto-generated method stub
System.out.println("SubClassOrImplClass1:doSomeThings...");
}
*//**
* 子类重写父类方法
* @Override 可以校验该方法是不是在父类(超类)中存在
*//*
@Override
public void doThings(){
System.out.println("SubClassOrImplClass1:doThings...");
}
}*/
public class SubClassOrImplClass1 implements SuperClassOrInterface {
/**
* 实现接口中指定的行为
*/
@Override
public void doSomeThings() {
// TODO Auto-generated method stub
System.out.println("SubClassOrImplClass1:doSomeThings...");
}
}
package h.ldemo.factorymethod;
/**
*
* @author: Is-Me-Hl
* @date: 2020年1月31日
* @Description: 子类2:继承或实现
*/
/*public class SubClassOrImplClass2 extends SuperClassOrInterface {
*//**
* 实现抽象方法
*//*
@Override
public void doSomeThings() {
// TODO Auto-generated method stub
System.out.println("SubClassOrImplClass2:doSomeThings...");
}
*//**
* 子类重写父类方法
* @Override 可以校验该方法是不是在父类(超类)中存在
*//*
@Override
public void doThings(){
System.out.println("SubClassOrImplClass2:doThings...");
}
}*/
public class SubClassOrImplClass2 implements SuperClassOrInterface {
/**
* 实现接口中指定的行为
*/
@Override
public void doSomeThings() {
// TODO Auto-generated method stub
System.out.println("SubClassOrImplClass2:doSomeThings...");
}
}
抽象工厂或接口工厂:
package h.ldemo.factorymethod;
/**
*
* @author: Is-Me-Hl
* @date: 2020年2月15日
* @Description: 抽象工厂或接口工厂
*/
public abstract class SuperFactoryOrFactoryInterface {
// 此处以抽象类为例,接口方式类似
// 获取实例
public abstract SuperClassOrInterface getInstance();
}
抽象工厂或接口工厂子类(举例两个):
package h.ldemo.factorymethod;
public class SubFactoryOrFactoryImpl1 extends SuperFactoryOrFactoryInterface {
@Override
public SuperClassOrInterface getInstance() {
// TODO Auto-generated method stub
System.out.println("具体工厂1实例化-->具体对象1...");
return new SubClassOrImplClass1();
}
}
package h.ldemo.factorymethod;
public class SubFactoryOrFactoryImpl2 extends SuperFactoryOrFactoryInterface {
@Override
public SuperClassOrInterface getInstance() {
// TODO Auto-generated method stub
System.out.println("具体工厂2实例化-->具体对象2...");
return new SubClassOrImplClass2();
}
}
测试类:
package h.ldemo.factorymethod;
/**
*
* @author: Is-Me-Hl
* @date: 2020年1月31日
* @Description: 测试
*/
public class TestMainEnter {
public static void main(String[] args) {
SuperFactoryOrFactoryInterface superFactory = new SubFactoryOrFactoryImpl1();
superFactory.getInstance().doSomeThings();
System.out.println("---------------------");
superFactory = new SubFactoryOrFactoryImpl2();
superFactory.getInstance().doSomeThings();
}
}
测试结果:
后分析
- 个人建议:写代码是件幸福的事,So,do it
工厂方法模式,定义一个用于创建对象的接口,让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
简单工厂VS工厂方法:
简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断,根据客户端的选择条件动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖。如简单工厂模式博客中讲的计算机的例子,你完成了加减乘除,但你需要计算次方的时候,你还需要对工厂进行修改,添加对应的case,这可不是一个好办法,就等于说,他们不但对扩展开放了,对修改也开放了,这个就违背了开放-封闭原则。那么工厂模式就发挥作用了。如上述代码所写的,我们每添加一个新的功能,只需要增加具体类和相应的工厂类即可,这就满足了开闭原则。
总结:工厂方法模式克服了简单工厂模式违背的开放-封闭原则的缺点,又保持了封装对象创建过程的优点。使得更换对象时,不需要做太大的改动就可以实现,降低了客户程序与产品对象的耦合。可以说,工厂方法是简单工厂模式的进一步抽象和推广。由于使用了多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。但工厂方法模式本身也存在瑕疵,由于每增加一个产品,就要添加一个产品工厂类,增加了额外的开发量。
其他例子:参考自《大话设计模式》雷锋工厂
注:以上文章仅是个人总结,若有不当之处,望不吝赐教