我要评论下午学习了设计模式里的策略模式，写个笔记，做个总结
策略模式的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] + ",");
}
}
}
您可能感兴趣的文章:
如您对本文有疑问或者有任何想说的，请点击进行留言回复，万千网友为您解惑！
网友评论