java设计模式之—策略模式strategy (案例：模拟java.lang.Comparable 和 java.util.Comparator) 灵活扩展，深入解析，让你专心写算法。

刺骨的言语ヽ痛彻心扉 2023-10-04 08:58 21阅读 0赞

> **前言：假如你对策略模式感兴趣，假如你对算法有一定了解（听说过也算），假如你对面向对象有一定了解（至少学过），来吧！**

## 引子：用最简便的代码，实现对int数组重新排序的功能。 ##

使用冒泡、选择、插入、希尔、快速、归并、堆这些算法，很轻松可以实现。

--------------------

## 延伸： ##

1、定义一个Cat类，分别用cat的height、weight、tail的长短、等对猫咪进行排序。

2、定义一个Dog类，要根据其food量、age 等，来排序。

3、定义一个Consumer消费者类，根据不同的VIP等级、不同的商品，打不同的折扣。

反思：要把程序的算法，做到灵活扩展，还是比较烧脑的。相信有不少同学，会想到代码里嵌套一个又一个if else,每次变动算法，都要把代码费劲的变更一下。学习完本案例，颠覆你的世界观，come on!

--------------------

## 正题： ##

1、轻松实现对int数组的排序（开胃菜）。

2、模拟java.lang.Comparable 和 java.util.Comparator，两个接口，实现对任意Object数组根据Object的某一属性值，进行排序，且可以轻松扩展。

编者的话：排序、算法是次要的，重要的是体会这种编程思想。

--------------------

爱学习的你，我们一起来进入正题吧！

### 案例一：对int数组，冒泡排序。 ###

#### 设计思路： ####

1、定义一个SortData类，类中分别定义：sortMaoPao、printArr两个方法，前者用来排序，后者用来打印数组。

对冒泡不是很熟悉的，可以复制下方代码，打断点、在纸上画画，略加思考（冒泡核心：每一轮外层大循环，把这轮循环中的数字中的最大或最小的，放到最前面，或最后面；这轮结束后，把剩下的数字，再按着这个规律……依次类推）。

public class DataSort {
    	
    	//冒泡排序
    	public static void  sortMaoPao (int [] arr) {
    		for(int i=arr.length;i>0;i--) {
    			for (int j = 0; j < i-1; j++) {
    				if(arr[j]>arr[j+1]) {
    					swap(arr,j,j+1);
    				}
    			}
    		}
    	}
    	
    	//交换两者的位置
    	private static void swap(int[] arr, int x, int y) {
    		int temp=arr[x];
    		arr[x]=arr[y];
    		arr[y]=temp;
    	}
    
    	public static void printArr(int [] arr) {
    		 for(int i=0;i<arr.length;i++) {
    			 System.out.print(arr[i]+"  ");
    		 }
    		 System.out.println();
    	}
    	
    	public static void main(String[] args) {
    		int [] arr= {6,3,11,2,9,10};
    		DataSort.sortMaoPao(arr);
    		DataSort.printArr(arr);
    	}
    }

> 运行结果：2 3 6 9 10 11

注：

1、通过上面的代码，热下身，重点在下面。

2、排序大同小异，在上面的sortMaoPao方法中，入参只能是int数组，如果换一个类，Cat Dog 等，还想用这个算法呢，怎么扩展？→→→

### 案例二：使用策略模式，对cat类，根据任意一可排序的属性，进行排序。 ###

#### 设计思路： ####

1、一个对象，要想实现排序，必有至少有一个可供排序的数组值，比如：年龄、身高、体重。

2、通过模拟java.lang.Comparable接口，让新建的Cat类implements该接口，统一需要作比的方法。

3、对上面的sortMaoPao()方法进行改装，里面的int数组，修改为T对象。并把这个方法，封装到接口实现类中，写成通用的可对任意数组排序的方法。

4、Cat类的各种算法，implements自定义的Compartor接口类，供灵活调配。

注：第一遍看不懂，没关系，复制粘贴运行一下。第二遍就懂了。看东西，看重点，代码稍微有点长。重点：是对 Comparable和Compartor的模拟。理解后，后面的扩展要多爽，有多爽。

#### 代码实现： ####

1、分别模拟java.lang.Comparable接口、java.util.Compartor接口，自己定义一个Comparable接口、Compartor接口。

//比较器:所有算法继承这个接口后，可以对算法灵活扩展
    public interface Compartor<T> {
    	/**
    	 * 前者>后者返回 1；前者<后者返回-1；两者相等，返回0
    	 * @param obj1
    	 * @param obj2
    	 * @return  1  -1   0
    	 */
    	int compare(T obj1,T obj2);
    }
    
    //所有类继承了这个接口后，都会有统一的比较方法。(核心思想：模拟java.lang.Comparable)
    public interface Comparable<T> {
    	/**
    	 * 统一规则：obj1>obj2返回1; 两者相等 返回0;obj1<obj2返回-1 （暂不考虑异常）
    	 * @param obj2
    	 * @param compartor
    	 * @return
    	 */
    	int compareTo(T obj2,Compartor<T> compartor);
    	int compareTo(T obj1,T obj2,Compartor<T> compartor);
    }

2、定义Cat类，重点是里面的两个比较方法（留一个就可以，主要是便于理解），其他是次要的。

//Cat类，implements Comparable，接口，使其具有统一的比较方法，便于任性扩展。
    public class Cat implements Comparable<Cat> {
    	private String name;
    	private int height;
    	private int weight;
    	
    	//核心代码
    	@Override
    	public int compareTo(Cat obj2,Compartor<Cat> compartor) {
    		return compartor.compare(this, obj2);//当前对象cat和传入对象cat2最比较
    	}
    	
    	@Override
    	public int compareTo(Cat obj1,Cat obj2,Compartor<Cat> compartor) {
    		return compartor.compare(obj1, obj2);//obj1和传入对象cat2最比较
    	}
    	
    	public Cat(String name,int height, int weight) {
    		super();
    		this.setName(name);
    		this.height = height;
    		this.weight = weight;
    	}
    
    	public int getHeight() {
    		return height;
    	}
    
    
    	public void setHeight(int height) {
    		this.height = height;
    	}
    
    
    	public int getWeight() {
    		return weight;
    	}
    
    
    	public void setWeight(int weight) {
    		this.weight = weight;
    	}
    
    	public String getName() {
    		return name;
    	}
    
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String toString() {
    		return "名称：" + name + "  身高：" + height + "  体重：" + weight +"\n";
    	}
    }

3、抽象排序算法，抽离成接口，命名为SortArr 统一排序方法。新建SortArrImpl具体实现排序。

//统一对数组，排序方法的接口
    interface SortArr<T> {
    	 void sortArr(T[] arr,Compartor<T> compartor);//对数组进行排序
    	 void printArr(T [] arr);//打印数组
    }
    
    
    //数组排序，方法类（注：是从大到小、还是从小到大排序，可对下方法自行改装）
    public class SortArrImpl<T> implements SortArr<T> {
    
        //这个写法的核心思想，就是冒泡排序
    	@Override
    	public void sortArr(T[] arr, Compartor<T> compartor) {
    		for(int i =arr.length;i>0;i--) {
    			for(int j=0;j<i-1;j++) {
    				if(compartor.compare(arr[j], arr[j+1])>0) {
    					T temp=arr[j];
    					arr[j]=arr[j+1];//数组中，下标为j,j+1的两个数相互交换value
    					arr[j+1]=temp;
    				}
    			}
    		}
    	}
    	
    	@Override
    	public  void printArr(T[] arr) {
    		 for(int i=0;i<arr.length;i++) {
    			 System.out.print(arr[i].toString());
    		 }
    		 System.out.println();
    	}
    }

4、收尾，测试环节。分别运行，根据身高排序、根据体重排序。

//用main方法，对案例进行测试的类
    public class SotMain {
    	 
    	public static void main(String[] args) {
    		Cat [] cats= {new Cat("妙妙",3, 4),new Cat("咪咪",8, 3),new Cat("花花",5, 7),new Cat("大白",4, 6),new Cat("小黑",11, 9)};
    		
    		SortArrImpl<Cat> sortImpl=new SortArrImpl<Cat> ();
    		
    		sortImpl.sortArr(cats, new CatHeightComparator());//根据身高排序
    		//sortImpl.sortArr(cats, new CatWeightComparator());//根据体重排序
    
    		sortImpl.printArr(cats);
    	}
    }

5、运行结果：

根据身高排序：sortImpl.sortArr(cats, new CatHeightComparator());

> 名称：妙妙 身高：3 体重：4  
> 名称：大白 身高：4 体重：6  
> 名称：花花 身高：5 体重：7  
> 名称：咪咪 身高：8 体重：3  
> 名称：小黑 身高：11 体重：9  
>

根据体重排序：sortImpl.sortArr(cats, new CatHeightComparator());

> 名称：咪咪 身高：8 体重：3  
> 名称：妙妙 身高：3 体重：4  
> 名称：大白 身高：4 体重：6  
> 名称：花花 身高：5 体重：7  
> 名称：小黑 身高：11 体重：9

### 总结： ###

1、如果再根据Cat尾巴的长短、食量排序，我们只需要新建CatTailComparator、CatFoodComparator分别实现Compartor接口就可以了。而Cat类本身的其他主题代码，不需要做任何改送。

2、相当于，算法可以单独抽离出来，灵活扩展，使用的时候，只需要把具体使用哪个算法传入到统一的方法中即可。正如下面这段代码：

//1、定义任意实现comparable接口的Object类。
    
    Cat [] cats= {new Cat("妙妙",3, 4),new Cat("咪咪",8, 3),new Cat("花花",5, 7),new Cat("大白",4, 6),new Cat("小黑",11, 9)};
    //2、调配统一的排序方法
    sortImpl.sortArr(cats, new CatWeightComparator());//根据传入不同的算法，来灵活排序。

### 后记： ###

1、再来只Dog 来头donkey，又如何，一切都在你的掌控之中。

2、策略模式的优缺点，略 略 略，自行体会（优点很明显、缺点找度娘，不再累述）。