《Design Patterns》FactoryMethod.积跬步系列

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，这可不是一个好办法，就等于说，他们不但对扩展开放了，对修改也开放了，这个就违背了开放-封闭原则。那么工厂模式就发挥作用了。如上述代码所写的，我们每添加一个新的功能，只需要增加具体类和相应的工厂类即可，这就满足了开闭原则。
总结：工厂方法模式克服了简单工厂模式违背的开放-封闭原则的缺点，又保持了封装对象创建过程的优点。使得更换对象时，不需要做太大的改动就可以实现，降低了客户程序与产品对象的耦合。可以说，工厂方法是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。但工厂方法模式本身也存在瑕疵，由于每增加一个产品，就要添加一个产品工厂类，增加了额外的开发量。

其他例子：参考自《大话设计模式》雷锋工厂

---

注：以上文章仅是个人总结，若有不当之处，望不吝赐教