java设计模式之工厂模式

        在上一篇《java设计模式之策略模式》中，我们针对提到的问题实现的解决方法有两种策略，看起来代码很容易上手维护，当然，上面提到的策略只是为了解决问题，但是你仔细的再考虑一下，如果有第三种，第四种乃至以后增加了更多的实现策略之后，抑或者是要解决不同的问题，那个时候你该怎么维护呢？用加法算？用乘法算？还是用加法与乘法结合起来算？no，no，这样就限制了同学们的发散性思维了，你只需要简单的一句命令：给我立马算出结果来，我不要知道过程，只要结果！这时候，学生们就开始根据自己的思维用五花八门的方法来解决问题了。这种现象是普遍存在的，那该怎么避免呢？想想，那该怎么办呢？问自己，java是啥？面向对象的。有解决的方法吗？这个必须得有啊。java设计模式中的工厂模式很好的避免这种没必要的现象。

工厂模式主要为创建对象提供过渡的接口，把创建对象的过程封闭起来，以便达到提高灵活性的目的。它主要分为3中模式：

         1.简单工厂模式

  又称为静态工厂模式，从名字上就可以看得出，简单嘛，只需要定义一个接口，用来创建对象就可以了。它由以下几部分组成：

（1）工厂类角色，一般由一个具体类来担任，是此模式的核心部分，里面可以实现一些逻辑性判断等。

        （2）抽象产品角色，具体产品继承的父类或者实现的接口，一般由抽象类或者接口担任。

（3）具体产品角色，由一个具体类来担任，工厂类中实现的对象就是此角色的具体实例。

  下面是代码的具体实现，代码就沿用上篇策略模式的，只是稍微改变了一下类名而已。

    抽象产品角色：

public interface IStrategy {
	int calculate(Calculate calculate);
}

具体产品角色：

public class PlusStraegy implements IStrategy{

	@Override
	public int calculate(Calculate calculate) {
		return (5+5+5+5+5);
	}

}

public class MultiplyStraegy implements IStrategy{

	@Override
	public int calculate(Calculate calculate) {
		System.out.println("MultiplyStraegy author is "+calculate.getAuthor());
		return (5*5);
	}

}

  工厂类角色：

public class CaculateFactory {
	public static IStrategy getStraegy(int method){
		switch (method) {
		case 0:
			return new PlusStraegy();
		case 1:
			return new MultiplyStraegy();
		default:
			return null;
		}
	}
}

好了，下面欢迎下命令的你，来提问题了。下命令的时候，发现报错，有问题？啥问题呢，因为上篇的时候，我们让策略对象持有了环境变量对象。因此，你发现了问题了没？上篇我们提到过的2种情况，你发散思维想一下，如果没有环境变量这一角色的存在，我们势必就得改策略了，正因为有了它，所以这个错误信息迎刃而解了啊，哈哈，代码如下：

public class StrategyTest {
	
	public static void main(String[] args) {
		
			Calculate calculate1 = new Calculate(CaculateFactory.getStraegy(0));
			System.out.println("PlusStraegy:apple sum = "+calculate1.calculate());
			
			Calculate calculate2 = new Calculate(CaculateFactory.getStraegy(1),"dandy");
			System.out.println("MultiplyStraegy:apple sum = "+calculate2.calculate());
	}
}

运行结果如下：
PlusStraegy:apple sum = 25
MultiplyStraegy author is dandy
MultiplyStraegy:apple sum = 25

2.工厂方法模式

其实与简单模式没啥区别，只不过是把工厂角色接口抽象出来，针对不同的产品来实现不同的子工厂。也就是一个抽象类产品角色对应一个抽象类工厂角色，一个具体产品角色对应一个具体工厂角色，就这么简单。具体角色由以下几种组成：

  （1）抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。 
       （2）具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。 
       （3）抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。 
       （4）具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。 

上面简单的工厂模式已经解决了问题，下命令者，也就是你，直接不用再担心创建产品对象的责任，而只是仅仅的去消耗产品得到结果就好了。那么接下来呢，只要有不同的策略实现，并且符合解决问题的原则，只要通知工厂类知道有这么一个策略之后，你就可以直接使用了，这符合设计模式中的开闭原则。但是工厂类这个时候就不太乐意了，因为没加一种策略，我就需要加一个逻辑判断，久而久之，或许这个判断就会很复杂，不易维护。因此，提供多个工厂方法势在必行了，针对每种对象，提供一种子工厂方法。多工厂方法模式使得对象的数量成倍的增长，显然这并不是我们想要的结果，为此，我们采用简单工厂模式与工厂方法模式的结合来实现，如以下代码所写：

public class CaculateFactory {
	
	public static IStrategy plusStraegy(){
		return new PlusStraegy();
	}
	
	public static IStrategy multiplyStraegy(){
		return new MultiplyStraegy();
	}
	
}

结果显然是正确的：

PlusStraegy:apple sum = 25
MultiplyStraegy author is dandy
MultiplyStraegy:apple sum = 25

通过以上2种模式看出，在一个产品树种，如果对于类似的产品我们可以采用以上2种模式的结合来实现。

3.抽象工厂模式

这个模式中，角色还是和工厂方法模式是一样的，只不过在抽象工厂类中，可能是拥有一个或者多个产品簇，当只有一个产品簇的时候，就真正的退化到工方法模式中了。

总结一下：

（1）简单工厂模式，就是一个具体的工厂类去实例化实现了同一接口或者同一父类的不同的对象产品

（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例 化操作延迟到子类中完成。 
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有 多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。