欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

设计模式---策略模式

程序员文章站 2022-07-10 17:44:21
下午学习了设计模式里的策略模式,写个笔记,做个总结 策略模式的UML图为: 举个例子: 我们每个人都想走向人生巅峰,但是怎么走向人生巅峰呢??有三个方法:1、当总经理;2、出任CEO;3、娶白富美。正好我身边有三个小伙伴,他们就想通过这三种策略来走向人生巅峰。。。 首先是走向人生巅峰的策略接口 然后 ......

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

策略模式的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] + ",");
        }
    }
}