《Design Patterns》SimpleFactory.积跬步系列

SimpleFactory：简单工厂模式

先代码

父类或接口类：

package h.l.demo.simplefactory;
/**
 * 
 * @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.l.demo.simplefactory;
/**
 * 
 * @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.l.demo.simplefactory;
/**
 * 
 * @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.l.demo.simplefactory;

/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年1月31日
 * @Description: 工厂类
 */
public class SimpleFactory {
	/**
	 * 通过工厂获取实例
	 * @param subType 子类型
	 * @return
	 */
	public static SuperClassOrInterface getInstance(String subType) {
		SuperClassOrInterface si = null;
		switch (subType) {
		case "SubClassOrImplClass1":
			si = new SubClassOrImplClass1();
			break;
		case "SubClassOrImplClass2":
			si = new SubClassOrImplClass2();
			break;
		}
		return si;
	}
}

测试类：

package h.l.demo.simplefactory;
/**
 * 
 * @author: Is-Me-Hl
 * @date: 2020年1月31日
 * @Description: 测试
 */
public class TestMainEnter {

	public static void main(String[] args) {
		SuperClassOrInterface si = SimpleFactory.getInstance("SubClassOrImplClass1");
		si.doSomeThings();
		// si.doThings();
		System.out.println("-----------------------");
		si = SimpleFactory.getInstance("SubClassOrImplClass2");
		si.doSomeThings();
		// si.doThings();
	}

}

测试结果：

后分析

• 个人建议：写代码是件幸福的事，So,do it

简单工厂模式，联系生活实际，可以类比于现实中的大米加工厂。这个加工厂收来自各个村庄的大米，甲村庄的大米是圆颗粒香糯型的，乙村庄的大米是长颗粒爽口型的，丙村庄的大米是低糖干瘪型的，丁村庄的大米则是圆润饱满型的。现实生活中是，大家会去加工厂挑选我们自己想要吃的哪种大米，很少有人会直接去个村庄农民伯伯家买大米吧。大伙都是直接向加工厂提要求：我要长颗粒爽口型的大米，那加工厂就会把乙村庄的大米卖给你；我血糖有些偏高，我需要低糖干瘪型的大米，那加工厂就会把丙村庄的大米提供给你。这个过程有没有发现，我们所买到的大米，实际上完全不关心他来自哪里。我们只需要向加工厂提要求就可以，至于我们要的大米来自哪里，这个由加工厂去找去负责。
实际上，简单工厂模式就是这个道理。我们可以将n个类的公共方法或者行为抽取出来作为父类的抽象方法或接口，由子类对抽象方法或接口进行实现。对于不同子类的创建，我们不在是new一个子类对象，而是将new的过程全权交由工厂去操作。被实例化类则对调用者屏蔽。

其他例子：参考自《大话设计模式》
如写一个计算器加减乘除，实际上都是对两个操作数据进行操作然后得出结论。更为准确的说，加减乘除都是对操作数据的操作行为。那么这个行为就应该被定义在接口中，由各个操作类中进行实现。因为子类很多，为了对调用者友好（不希望调用者要很辛苦的去记得调用加法方法得去new加运算的类，减法由去new一个减运算的类），我们通过工厂给了一个统一的入口，调用者将运算符传入，我们给他返回对应的运算类即可。好处嘛：挺明显，比new A();new B();new 啊不次的();方便多了吧。可千万别说不就个加减乘除嘛，我全写在main方法中，一个方法搞定，那我不敢出声了，自个加油。

---

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