java设计模式 -------- 创建模式 之 简单工厂模式

       本文是自己学习所做笔记，欢迎转载，但请注明出处：http://blog.youkuaiyun.com/jesson20121020       

 

      工厂模式是最常用的模式，因为工厂模式就相当于创建实例对象的new，我们经常要根据类Class生成实例对象，如A a = new A()，工厂模式也是用来创建用来创建实例对象的，所以以后new时要多个心眼，是否可以考虑使用工厂模式。

      简单工厂模式又可以分成三种模式：

                 1） 普通简单工厂模式

                 2） 多方法简单工厂模式

                 3） 多静态方法简单工厂模式

普通简单工厂模式：

      举例：（简单的四则运算）

      1.  创建四则运算的共同接口：

//操作类接口
public interface Operator{

	public double Operate(double d,double e);
}

     2.  创建加减乘除实现类：

//加法类
public class AddOperator implements Operator{
	@Override
	public double Operate(double a, double b) {
		// TODO Auto-generated method stub
		return a + b;
	}
}

public class SubOperator implements Operator {

	@Override
	public double Operate(double a, double b) {
		// TODO Auto-generated method stub
		return a - b;
	}
}

public class MulOperator implements Operator {

	@Override
	public double Operate(double a, double b) {
		// TODO Auto-generated method stub
		return a * b ;
	}
}

public class DivOperator implements Operator {
	@Override
	public double Operate(double a, double b) {
		
			try {
				if(b == 0)
					throw new Exception("除数不能为0!");
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		return a / b;
	}
}

      3.  创建工厂类：

public class OperatorFactory {
	public Operator createOperator(String operate){
		Operator oper = null;
		switch(operate){
			case "+" :
				oper = new AddOperator();
				break;
			case "-" :
				oper = new SubOperator();
				break;
			case "*" :
				oper = new MulOperator();
				break;
			case "/" :
				oper = new DivOperator();
				break;
		}
		return oper;
	}
}

     4. 最后就是测试类了：

public class FactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OperatorFactory factory = new OperatorFactory();
		Operator oper = factory.createOperator("*");
		double result = oper.Operate(3.6,4.8);
		System.out.println(result);
	}

}

    

多方法简单工厂模式：

       在上述普通简单工厂模式中，设想这样一种状况，如果传递进来的参数是空，或者是别的不合法字符，则不能正确的创建对象，而多方法简单工厂模式则提供多个工厂方法，分别创建对象。

       和普通的不同之处仅在工厂类，改动如下：

public class OperatorFactory {
	
	public Operator createAddOperator(){
		return new AddOperator();
	}
	public Operator createSubOperator(){
		return new SubOperator();
	}
	public Operator createMulOperator(){
		return new MulOperator();
	}
	public Operator createDivOperator(){
		return new DivOperator();
	}
}

     这样，在测试时，就不需要传递相应的参数，只需要调用需要的工厂方法，即可：

public class FactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		OperatorFactory factory = new OperatorFactory();
		/*Operator oper = factory.createOperator("*");*/
		Operator oper = factory.createMulOperator();
		double result = oper.Operate(3.6,4.8);
		System.out.println(result);
	}
}

多静态方法简单工厂模式：

       所谓的静态方法，即将上面工厂类中的工厂方法置为静态的，不需要创建实例，直接调用即可。

public class OperatorFactory {
	
	public static Operator createAddOperator(){
		return new AddOperator();
	}
	public static Operator createSubOperator(){
		return new SubOperator();
	}
	public static  Operator createMulOperator(){
		return new MulOperator();
	}
	public static Operator createDivOperator(){
		return new DivOperator();
	}
}

        如上，将工厂方法设为静态的，则在测试时，直接调用即可。

public class FactoryTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 //OperatorFactory factory = new OperatorFactory();
		/*Operator oper = factory.createOperator("*");*/
		Operator oper = OperatorFactory.createMulOperator();
		double result = oper.Operate(3.6,4.8);
		System.out.println(result);
	}
}

      

         总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。