策略模式实例与解析--实例一：排序策略

某系统提供了一个用于对数组数据进行操作的类，该类封装了对数组的常见操作，如查找数组元素、对数组元素进行排序等。现以排序操作为例，使用策略模式设计该数组操作类，使得客户端可以动态地更换排序算法，可以根据需要选择冒泡排序或选择排序或插入排序，也能够灵活地增加新的排序算法。

 

public class ArrayHandler
{
	private Sort sortObj;
	
	public int[] sort(int arr[])
	{
		sortObj.sort(arr);
		return arr;
	}

	public void setSortObj(Sort sortObj) {
		this.sortObj = sortObj; 
	}
}

public class BubbleSort implements Sort
{
	public int[] sort(int arr[])
	{
	   int len=arr.length;
       for(int i=0;i<len;i++)
       {
           for(int j=i+1;j<len;j++)
           {
              int temp;
              if(arr[i]>arr[j])
              {
                  temp=arr[j];
                  arr[j]=arr[i];
                  arr[i]=temp;
              }             
           }
		}
		System.out.println("冒泡排序");
		return arr;
	}
}

public class Client
{
	public static void main(String args[])
	{
	   int arr[]={1,4,6,2,5,3,7,10,9};
	   int result[];
	   ArrayHandler ah=new ArrayHandler();
	   
	   Sort sort;
       sort=(Sort)XMLUtil.getBean();
       
       ah.setSortObj(sort); //设置具体策略
       result=ah.sort(arr);
       
       for(int i=0;i<result.length;i++)
       {
       	    System.out.print(result[i] + ",");
       }
	}
}

配置文件config.xml：



<?xml version="1.0"?>
<config>
    <className>QuickSort</className>
</config>

public class InsertionSort implements Sort
{
	public int[] sort(int arr[])
	{
 	   int len=arr.length;
       for(int i=1;i<len;i++)
       {
           int j;
           int temp=arr[i];
           for(j=i;j>0;j--)
           {
              if(arr[j-1]>temp)
              {
                  arr[j]=arr[j-1];
                  
              }else
                  break;
           }
           arr[j]=temp;
		}
		System.out.println("插入排序");
		return arr;
	}
}

public class QuickSort implements Sort
{
	public int[] sort(int arr[])
	{
		System.out.println("快速排序");
		sort(arr,0,arr.length-1);
		return arr;
	}

	public void sort(int arr[],int p, int r)
	{
		int q=0;
		if(p<r)
		{
			q=partition(arr,p,r);
			sort(arr,p,q-1);
            sort(arr,q+1,r);
		}
	}
	
	public int partition(int[] a, int p, int r)
	{
		int x=a[r];
		int j=p-1;
		for(int i=p;i<=r-1;i++)
		{
			if(a[i]<=x)
			{
				j++;
				swap(a,j,i);
			}
		}
		swap(a,j+1,r);
		return j+1;	
	}
	
	public void swap(int[] a, int i, int j) 
	{   
        int t = a[i];   
        a[i] = a[j];   
        a[j] = t;   
	}
}

public class SelectionSort implements Sort
{
	public int[] sort(int arr[])
	{
	   int len=arr.length;
       int temp;
       for(int i=0;i<len;i++)
       {
           temp=arr[i];
           int j;
           int samllestLocation=i;
           for(j=i+1;j<len;j++)
           {
              if(arr[j]<temp)
              {
                  temp=arr[j];
                  samllestLocation=j;
              }
           }
           arr[samllestLocation]=arr[i];
           arr[i]=temp;
       }
       System.out.println("选择排序");
       return arr;
	}
}

public interface Sort
{
	public abstract int[] sort(int arr[]);
}

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
	public static Object getBean()
	{
		try
		{
			//创建文档对象
			DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
			DocumentBuilder builder = dFactory.newDocumentBuilder();
			Document doc;							
			doc = builder.parse(new File("config.xml")); 
		
			//获取包含类名的文本节点
			NodeList nl = doc.getElementsByTagName("className");
            Node classNode=nl.item(0).getFirstChild();
            String cName=classNode.getNodeValue();
            
            //通过类名生成实例对象并将其返回
            Class c=Class.forName(cName);
	  	    Object obj=c.newInstance();
            return obj;
           }   
           	catch(Exception e)
           	{
           		e.printStackTrace();
           		return null;
           	}
		}
}