设计模式(二)策略模式
- 一、概念
- 二、学习准备
- 三、代码实现
- 四、`Comparator`策略模式
一、概念
策略(Strategy)模式的定义:该模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式,它通过对算法进行封装,把使用算法的责任和算法的实现分割开来,并委派给不同的对象对这些算法进行管理。
二、学习准备
要先学习策略模式,首先要去了解2个接口Comparator
和Comparable
(1)Comparator
:
通过jdk1.8的api文档了解:Comparator
的抽象方法
详细方法信息:
(2)Comparable
三、代码实现
通过一系列例子了解什么是策略思想
先写一个排序:
public class Main {
public static void main(String[] args) {
int [] a={9,2,3,5,7,1,4,6,8};
Sorter sorter=new Sorter();
sorter.sort(a);
System.out.println(Arrays.toString(a));
}
}
这里我使用的选择排序法:
public class Sorter {
public int[] sort(int[] arr) {
if (arr == null && arr.length == 0) {
return arr;
}
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
min = arr[min] > arr[j] ? j : min;
}
sweap(arr,i, min);
}
return arr;
}
public static void sweap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
代码简单的实现了对int类型的数组排序,在问题来了,我要是对double类型进行排序,怎么办呢?
在写一个sort,把int类型改成double。如果是flot类型排序?又要重写一个sort方法。这样是不是很麻烦呢?
有不有一种更简单的写法呢?不用重写那么多sort?
继续看:
新建一个类Cat 实例:
public class Cat {
@Override
public String toString() {
return "Cat{" +
"weight=" + weight +
", height=" + height +
'}';
}
int weight, height;
public Cat(int weight, int height) {
this.height = height;
this.weight = weight;
}
public int compareTo(Cat c) {
if (this.weight < c.weight) {
return -1;
} else if (this.weight > c.weight) {
return 1;
} else {
return 0;
}
}
}
现在我们想,怎么在sort里面对Cat进行排序呢?
所以在Cat实例里面写一个 Cat的compareTo方法比较2个猫的weight,定义猫怎么比较大小。再将sort改成接收Cat类型的方法
public class Sorter {
public void sort(Cat[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
min = arr[j].compareTo(arr[min]) == -1 ? j : min;
}
sweap(arr, i, min);
}
}
public static void sweap(Cat[] arr, int i, int j) {
Cat tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
看看结果:
public class Main {
public static void main(String[] args) {
Cat[] a={new Cat(3,3),new Cat(2,2),new Cat(4,4)};
Sorter sorter=new Sorter();
sorter.sort(a);
System.out.println(Arrays.toString(a));
}
}
现在我们对一个对象按照weight属性进行了排序,这时,我们要是对狗,对蛇 ,对人排序呢?岂不是又要修改sort方法吗?
所以在sort上写死类型是不行的。
就有人想到将sort接收类型改成Object不就行了吗?可Objerct里面没有compareTo方法呀。很简单
所以,我可以这样设计,所有要求实现sort方法的类型去重写里面的compareTo方法
直接去实现java.lang下面的Comparable接口,这个接口里面有个compareTo方法
详见头部api文档接口用法
自己手撸一个Comparable
接口实现:
新建Comparable
接口:
public interface Comparable {
int compareTo(Object o);
}
新建一个Dog实例实现Comparable
并重写compareTo
方法:
注意:由于实现的compareTo
方法为Object类型,则需要在重写的时候,需要强转为当前实例对象
public class Dog implements Comparable {
int food;
public Dog(int food) {
this.food = food;
}
@Override
public String toString() {
return "Dog{" +
"food=" + food +
'}';
}
@Override
public int compareTo(Object o) {
Dog d= (Dog) o;
if (this.food<d.food){
return -1;
}else if (this.food>d.food){
return 1;
}else {
return 0;
}
}
}
在sort方法中将接收对象改为Comparable
public class Sorter {
public void sort(Comparable[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
min = arr[j].compareTo(arr[min]) == -1 ? j : min;
}
swap(arr, i, min);
}
}
public static void swap(Comparable[] arr, int i, int j) {
Comparable tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
在看结果:
public class Main {
public static void main(String[] args) {
Dog[] a={new Dog(3),new Dog(5),new Dog(2)};
Sorter sorter=new Sorter();
sorter.sort(a);
System.out.println(Arrays.toString(a));
}
}
虽然我们用需要比较的实例重写了Comparable
中的compareTo
方法后,每次比较都不需要进行更改sort方法中的接收类型了
但是:发现没有?每次重写compareTo
方法的时候,都需要强制转换。有时候还会出错。
所以我们可以采用java中泛型的写法:
修改Comparable
接口:
public interface Comparable<T> {
int compareTo(T o);
}
更改Dog实例:
public class Dog implements Comparable<Dog> {
int food;
public Dog(int food) {
this.food = food;
}
@Override
public String toString() {
return "Dog{" +
"food=" + food +
'}';
}
@Override
public int compareTo(Dog d) {
if (this.food<d.food){
return -1;
}else if (this.food>d.food){
return 1;
}else {
return 0;
}
}
}
在去执行main方法,结果就是我们想要的结果。
有了以上的基础后,我们再来了解什么是策略模式。
四、Comparator
策略模式
虽然现在sort方法能去排序Comparable类型的对象,但是还不够灵活,在Cat中,我们通过weight来比较猫的大小,如果我们用hight来觉得它的大小呢?所以:我想猫比较大小的策略可以灵活的指定,这时候怎么做?
有人说,我把Cat重写的compareTo方法重新写不就行了吗?这相当于重新更改功能,如果每次都要更改,岂不是很麻烦?所以我们可以对compareTo方法进行拓展Comparator
:比较器,其实就是比较策略
新建Comparator
接口
public interface Comparator<T> {
int compare(T o1, T o2);
}
新建一个类的比较器:例如DogComparator
public class DogComparator implements Comparator<Dog> {
@Override
public int compare(Dog o1, Dog o2) {
if (o1.food < o2.food) {
return -1;
} else if (o1.food > o2.food) {
return 1;
} else {
return 0;
}
}
}
更改sort方法,接收类型为泛型,在加入比较器Comparator
public class Sorter<T> {
public void sort(T[] arr, Comparator<T> comparator) {
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
min = comparator.compare(arr[j], arr[min]) == -1 ? j : min;
}
swap(arr, i, min);
}
}
public void swap(T[] arr, int i, int j) {
T tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
public class Main {
public static void main(String[] args) {
Dog[] a={new Dog(3),new Dog(5),new Dog(2)};
Sorter<Dog> sorter=new Sorter<>();
sorter.sort(a,new DogComparator());
System.out.println(Arrays.toString(a));
}
}
通过实现Comparator的compare方法,使代码拓展更强了
后面如果要拓展代码的比例方式,只需更改重写实例类compare就可以了。
举个例:
创建Cat的比较器CatWeightComparator
用neight
来比较猫的大小
public class CatWeightComparator implements Comparator<Cat> {
@Override
public int compare(Cat o1, Cat o2) {
if (o1.neight< o2.neight) {
return -1;
} else if (o1.neight> o2.neight) {
return 1;
} else {
return 0;
}
}
}
public class Main {
public static void main(String[] args) {
Cat[] a={new Cat(3,3),new Cat(2,2),new Cat(4,4)};
Sorter<Cat> sorter=new Sorter<>();
sorter.sort(a,new CatWeightComparator());
System.out.println(Arrays.toString(a));
}
}
我们可以通过实现Comparator
接口比较器的策略,选择我们所需的策略进行排序
总结:策略模式封装的就是做一件事情不同的执行方式,比如排序的策略,根据不同的排序要求,选择不同的排序策略