设计模式初体验——工厂模式

        上课要求编写一个程序，实现插入排序的递归实现和非递归实现的效率问题。想到直接写在main里面各种调用觉得是不是有点low了。最近无事拿着设计模式的书在翻，突然想到了有一个工厂模式，于是乎就借着这个机会实践实践。

       背景：使用java程序实现对插入排序的递归实现和非递归实现的效率的比较。

       首先创建一个MyInsertSort接口，这个接口里面其实就一个简单的sort方法

package l78z.insertSort;


public interface MyInsertSort
{
	public void sort(int [] array,int index,int length);
}

然后分别创建两个具体类，分别是使用递归方式实现的插入排序，和使用非递归方式实现的插入排序（ps：具体的事件是从百度拷贝的）

/**
* @Title: RecursiveImplemnt.java
* @Package l78z.insertSort
* @Description: TODO(用一句话描述该文件做什么)
* @author matao@cqrainbowsoft.com
* @date 2015年11月26日 下午4:51:23
* @version V1.0
*/
package l78z.insertSort;


public class RecursiveImplemnt implements MyInsertSort
{

	/* (非 Javadoc) 
	* <p>Title: sort</p> 
	* <p>Description: </p> 
	* @param array
	* @param index
	* @param length 
	* @see l78z.insertSort.MyInsertSort#sort(int[], int, int) 
	*/
	@Override
	public void sort(int[] array, int index, int length)
	{
		if (index >= length)  
	    {  
	        return;  
	    }  
	  
	    int key = array[index];//记录当前待插入的元素    
	    int i=0;  
	    for (i=index-1; i>=0&&key<array[i]; i--)  
	    {  
	        array[i+1] = array[i];          
	    }  
	    array[i+1] = key;  
	    sort(array, index+1, length);  
	}
	
}

/**
* @Title: UnrecuisiveImplement.java
* @Package l78z.insertSort
* @Description: TODO(用一句话描述该文件做什么)
* @author matao@cqrainbowsoft.com
* @date 2015年11月26日 下午4:52:00
* @version V1.0
*/
package l78z.insertSort;

public class UnrecuisiveImplement implements MyInsertSort
{

	/* (非 Javadoc) 
	* <p>Title: sort</p> 
	* <p>Description: </p> 
	* @param array
	* @param index
	* @param length 
	* @see l78z.insertSort.MyInsertSort#sort(int[], int, int) 
	*/
	@Override
	public void sort(int[] array, int index, int length)
	{
		if (array == null || length <= 0)  
	    {  
	        return;  
	    }  
	       
	    int key = 0;  
	    int j=0;  
	    for (int i=1; i<length; i++)  
	    {  
	        if (array[i] < array[i-1])//当前带插入的元素比有序序列的最后一个元素小  
	        {  
	           key = array[i];  
	           for (j=i-1; j>=0&&key<array[j]; j--)  
	           {  
	               array[j+1] = array[j];             
	           }  
	           array[j+1] = key;  
	        }  
	    }  
		
	}
	
}

        在创建了以上三个类之后，我们需要每个具体类对应的工程厂类，在创建对应的工厂类之前我们需要创建一个抽象的工厂，这个抽象类里面就一个简单的创建插入排序实例的接口，其他的也没什么

/**
* @Title: AbstarctFactory.java
* @Package l78z.insertSort
* @Description: TODO(用一句话描述该文件做什么)
* @author matao@cqrainbowsoft.com
* @date 2015年11月26日 下午4:54:13
* @version V1.0
*/
package l78z.insertSort;

public interface AbstarctFactory
{
	public MyInsertSort createInsertSort();
}

在创建了接口之后分别创建插入排序的递归实现的工厂类和非递归实现的工厂类

/**
* @Title: RecursiveFactory.java
* @Package l78z.insertSort
* @Description: TODO(用一句话描述该文件做什么)
* @author matao@cqrainbowsoft.com
* @date 2015年11月26日 下午4:55:12
* @version V1.0
*/
package l78z.insertSort;

public class RecursiveFactory implements AbstarctFactory
{
	/* (非 Javadoc) 
	* <p>Title: createInsertSort</p> 
	* <p>Description: </p> 
	* @return 
	* @see l78z.insertSort.AbstarctFactory#createInsertSort() 
	*/
	@Override
	public MyInsertSort createInsertSort()
	{
		return new RecursiveImplemnt();
	}
	
}

/**
* @Title: UnrcursiveFactory.java
* @Package l78z.insertSort
* @Description: TODO(用一句话描述该文件做什么)
* @author matao@cqrainbowsoft.com
* @date 2015年11月26日 下午4:56:19
* @version V1.0
*/
package l78z.insertSort;

public class UnrcursiveFactory implements AbstarctFactory
{

	/* (非 Javadoc) 
	* <p>Title: createInsertSort</p> 
	* <p>Description: </p> 
	* @return 
	* @see l78z.insertSort.AbstarctFactory#createInsertSort() 
	*/
	@Override
	public MyInsertSort createInsertSort()
	{
		// TODO Auto-generated method stub
		return new UnrecuisiveImplement();
	}
	
}

        完成以上的步骤那么我们的准备工作就全部做完了。

        1）一个抽象的产品类——MyInsertSort

        2）两个或多个的具体产品类——RecursiveImplemnt、UnrecuisiveImplement

        3）一个抽象的工厂类——AbstarctFactory

        4）两个或多个具体产品对应的工厂类——RecursiveFactory、UnrcursiveFactory

        然后我们再看我们的测试类

/**
* @Title: Main.java
* @Package l78z.insertSort
* @Description: TODO(用一句话描述该文件做什么)
* @author matao@cqrainbowsoft.com
* @date 2015年11月26日 下午4:56:59
* @version V1.0
*/
package l78z.insertSort;

import l78z.L78ZUtil;

public class Main
{
	/** 
	 * @Title: Main 
	 * @Description: TODO(这里用一句话描述这个方法的作用)  
	 */
	public static String clazz= "l78z.insertSort.UnrcursiveFactory";
	
	public static void main(String[] args)
	{
		try
		{
			AbstarctFactory factory = (AbstarctFactory)Class.forName(clazz).newInstance();
			MyInsertSort insertSort = factory.createInsertSort();
			test(insertSort,"非递归测试");//这里可以传一个参数
		} catch (Exception e)
		{
			e.printStackTrace();
		}
	}
	public static void test(MyInsertSort insertSort ,String label)
	{
		System.out.println(label);
		for (int i = 1000; i < 10000; i+=1000)
		{
			int [] array = L78ZUtil.generateIntArray(i);
			L78ZUtil.timeStart();
			insertSort.sort(array, 0, array.length);
			L78ZUtil.timeEnd();
			Long result = null;
			try
			{
				result = L78ZUtil.getTime();
			} catch (Exception e)
			{
				e.printStackTrace();
			}
			System.out.println("规模是 "+i+ " 用时为"+result);
		}
	}
}

        到这里就基本上大功告成了，这样就实现了即使我们改变了外部条件（我需要测试递归方法和非递归方法）我们也不需要更改java代码。

（ps：这里的clazz为了方便我就没有都xml文件了，正确的做法是在xml文件中读取我们需要测试的类，测试了递归方法之后只需要将xml文件中的clazz改成非递归方法对应的类那么我们就可以直接测试了）

        纯属新手体验，有什么不对的地方望指正