设计模式---策略模式

下午学习了设计模式里的策略模式，写个笔记，做个总结

策略模式的UML图为：

 

举个例子：

我们每个人都想走向人生巅峰，但是怎么走向人生巅峰呢？？有三个方法：1、当总经理；2、出任CEO；3、娶白富美。正好我身边有三个小伙伴，他们就想通过这三种策略来走向人生巅峰。。。

 

首先是走向人生巅峰的策略接口

package com.designmodel.strategy;

/**
 * 走向人生巅峰的策略接口
 *
 */
public interface IStrategy {

    void operate();
}

然后是三种走向人生巅峰的策略，三种策略都实现这个接口

策略一：当总经理

package com.designmodel.strategy;
/**
 *  策略一 当个总经理
 *
 */
public class BeGeneralManagerStrategy implements IStrategy {

    @Override
    public void operate() {
        System.out.println("当总经理");

    }
}

策略二：出任CEO

package com.designmodel.strategy;
/**
 * 策略二 出任CEO
 *
 */
public class BeCEOStrategy implements IStrategy {

    @Override
    public void operate() {
        System.out.println("出任CEO");

    }
}

策略三：娶白富美

package com.designmodel.strategy;
/**
 * 策略三 娶个白富美
 * @author Administrator
 *
 */
public class MarryWithRichStategy implements IStrategy {

    @Override
    public void operate() {
        System.out.println("娶白富美");
    }
}

最后，有个执行这些策略的环境

package com.designmodel.strategy;
/**
 * 执行策略的环境
 *
 */
public class Context {

    private IStrategy strategy;
    public Context(IStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void operate() {
        strategy.operate();
    }
}

好了，这些都具备了，策略模式也就展现出来了。现在我的三个小伙伴，钱同学想通过当CEO走向人生巅峰，李同学想通过当总经理走向人生巅峰，张同学只想癞蛤蟆吃天鹅肉，娶白富美走向人生巅峰

package com.designmodel.strategy;

public class MainApp {

    public static void main(String[] args) {
        // 钱同学的愿望是出任CEO, 从而走向人生巅峰
        // 钱同学的策略是...
        BeCEOStrategy qianStrategy = new BeCEOStrategy();
        // 所以钱同学的策略环境是...
        Context qianContext = new Context(qianStrategy);
        // 在该环境下执行策略...
        System.out.print("钱同学走向人生巅峰的方法是:");
        qianContext.operate();
        
        // 李同学不想出任CEO, 就当个总经理就满足了, 因此...
        BeGeneralManagerStrategy liStrategy = new BeGeneralManagerStrategy();
        Context liContext = new Context(liStrategy);
        System.out.print("李同学走向人生巅峰的方法是:");
        liContext.operate();
        
        // 张同学是癞蛤蟆想吃天鹅肉, 打算傍个白富美走向人生巅峰, 所以...
        MarryWithRichStategy zhangStrategy = new MarryWithRichStategy();
        Context zhangContext = new Context(zhangStrategy);
        System.out.print("张同学走向人生巅峰的方法是:");
        zhangContext.operate();
    }
}

执行结果为：

钱同学走向人生巅峰的方法是:出任CEO
李同学走向人生巅峰的方法是:当总经理
张同学走向人生巅峰的方法是:娶白富美

 

 

 

再举一个例子，通常的排序算法有四种，插入排序，冒泡排序，快速排序和选择排序，这也就是对应着4种策略。

排序接口：

package com.designmodel.strategy;

public interface Sort {

    public abstract int[] sort(int arr[]);
}

四个排序策略：

1.插入排序

package com.designmodel.strategy;

public class InsertionSort implements Sort {

    @Override
    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;
    }
}

2.冒泡排序

package com.designmodel.strategy;

public class BubbleSort implements Sort {

    @Override
    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;
    }

}

3.快速排序

package com.designmodel.strategy;

public class QuickSort implements Sort {

    @Override
    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;   
    }

}

4.选择排序

package com.designmodel.strategy;

public class SelectionSort implements Sort {

    @Override
    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;
    }

}

读取XML配置文件工具类

package com.designmodel.strategy;

import javax.xml.parsers.*;
import org.w3c.dom.*;
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;
        }
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8"?>
<config>
    <className>QuickSort</className>
</config>

还有执行策略的环境

package com.designmodel.strategy;

public class ArrayHandler {

    private Sort sortObj;
    
    public int[] sort(int arr[]) {
        sortObj.sort(arr);
        return arr;
    }
    
    public void setSortObj(Sort sortObj) {
        this.sortObj = sortObj;
    }
}

最后是main函数

package com.designmodel.strategy;

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] + ",");
        }
    }
}