前言
前排提示：这是一个学习笔记，参照马士兵老师和韩顺平老师设计模式的视频学习的笔记。记录下来纯为巩固和方便日后的复习！
参考：
韩顺平老师：https://www.bilibili.com/video/BV1G4411c7N4?from=search&seid=15531256878937056259
马士兵老师：https://www.bilibili.com/video/BV1tK411W7xx?from=search&seid=15531256878937056259
设计模式（序）——设计模式初识和原则
设计模式（一）——单例模式
设计模式（二）——策略模式
设计模式（三）——简单工厂和抽象工厂
五、策略模式
5.1初识
思考一
首先写一个能够对int数组进行排序的排序类和一个主类。在排序类中实现排序方法，在主类中初始化数组并将调用排序方法给数组排序。
主类：
public class Main {
public static void main(String[] args) {
int[] a = {9,2,3,5,7,1,4};
Sorter sorter = new Sorter();
sorter.sort(a);
System.out.println(Arrays.toString(a));
}
}
排序类：
public class Sorter {
public void sort(int[] arr) {
for (int i = 0; i < arr.length; i++) {
int min = i;
for (int j = i+1; j < arr.length; j++) {
min = arr[j]问题：如果还要对double类型的数组、float类型的数组进行排序，该如何做？
思考二
再编写一个cat类用于比较两只猫的大小。
Cat类：
public class Cat {
int weight,height;
public Cat(int weight,int height){
this.weight = weight;
this.height = height;
}
/**
* 定义比较两只猫大小的方法
*/
public int compareTo(Cat cat){
if (this.weight cat.weight){
return -1;
}else {
return 0;
}
}
@Override
public String toString() {
return "Cat{" +
"weight=" + weight +
", height=" + height +
'}';
}
}
排序类的改造：
public class Sorter {
public void sort(Cat[] arr) {
for (int i = 0; i < arr.length; 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);
}
}
static void swap(Cat[] arr, int i, int j)
{
Cat temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
问题：如果还需要对Dog、Snake进行排序，该如何做？如果要对各种类型的数据或对象排序又该怎么做？
解决问题
首先，既然要对多个对象进行比较，那么排序类中传入的对象不能为指定好的对象，必须改为Object类。
其次，如果传入的类为Object类，但是Object类中并没有compareTo()方法。因此我们这里写一个接口，接口中有compareTo()方法；或者使用Java自带的Comparable接口
为了复习一下泛型，我们还是自己写一个Comparable接口，在接口中写一个compareTo()方法。在对象类中实现Comparable接口，并实现其compareTo()方法。
//修改后的排序类
public class Sorter {
public void sort(Comparable[] arr) {
for (int i = 0; i < arr.length; 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);
}
}
static void swap(Comparable[] arr, int i, int j) {
Comparable temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
//Comparable接口
public interface Comparable {
int compareTo(Object o);
}
//修改需要排序的类
public class Cat implements Comparable{
int weight,height;
public Cat(int weight,int height){
this.weight = weight;
this.height = height;
}
@Override
public String toString() {
return "Cat{" +
"weight=" + weight +
", height=" + height +
'}';
}
@Override
public int compareTo(Object o) {
Cat cat = (Cat) o;
if (this.weight cat.weight){
return -1;
}else {
return 0;
}
}
}
public class Dog implements Comparable{
private int food;
public Dog(int food){
this.food = food;
}
@Override
public int compareTo(Object o) {
Dog dog = (Dog) o;
if (this.food dog.food){
return 1;
}else {
return 0;
}
}
@Override
public String toString() {
return "Dog{" +
"food=" + food +
'}';
}
}
在主类中测试，对Dog类和Cat类进行排序
public class Main {
public static void main(String[] args) {
// int[] a = {9,2,3,5,7,1,4};
// Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
Dog[] a = {new Dog(1),new Dog(3),new Dog(2)};
Sorter sorter = new Sorter();
sorter.sort(a);
System.out.println(Arrays.toString(a));
}
}
运行结果：
#Cat
[Cat{weight=1, height=1}, Cat{weight=3, height=3}, Cat{weight=5, height=5}]
Process finished with exit code 0
#Dog
[Dog{food=1}, Dog{food=2}, Dog{food=3}]
Process finished with exit code 0
至此排序类就可以对Cat类和Dog类进行排序了。但是由于每次在Cat类和Dog类中的compareTo()方法中都需要进行强制转换，在强制转换中可能会出现类的错误异常，因此可以引入泛型的概念。
修改comparable接口
public interface Comparable {
int compareTo(T o);
}
这样就可以在Cat类和Dog类实现Comparable接口时指定T。
//重新修改Dog类
public class Dog implements Comparable{
private int food;
public Dog(int food){
this.food = food;
}
@Override
public int compareTo(Dog o) {
if (this.food o.food){
return 1;
}else {
return 0;
}
}
@Override
public String toString() {
return "Dog{" +
"food=" + food +
'}';
}
}
Cat类同理，在此省略。
总结
通过这个例子我们了解到了如何Comparable接口和泛型的使用，但是这个还不算策略模式。下面我们再继续思考一下，在Cat类中我们定义了weight和height两种属性，而做比较的时候只用到了weight作为比较的基准，如果比较两只猫的大小还需要从height上进行比较呢？又或者需要综合weight和height一起比较呢？
5.2 Comparator比较器
为了解决上述问题，编写一个比较器接口
public interface Comparator {
int compare(T o1,T o2);
}
编写两个类来实现这个比较器接口，分别实现按Cat的weight来比较大小和Cat的height来比较大小。
public class CatWeightComparator implements Comparator{
@Override
public int compare(Cat o1, Cat o2) {
if (o1.weight o2.weight){
return 1;
}else {
return 0;
}
}
}
public class CatheightComparator implements Comparator{
@Override
public int compare(Cat o1, Cat o2) {
if (o1.height o2.height){
return -1;
}else {
return 0;
}
}
}
最后改造排序类
public class Sorter {
public void sort(T[] arr,Comparator comparator) {
for (int i = 0; i < arr.length; 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 temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
在主类测试
public class Main {
public static void main(String[] args) {
// int[] a = {9,2,3,5,7,1,4};
Cat[] a = {new Cat(3, 3), new Cat(5, 5), new Cat(1, 1)};
// Dog[] a = {new Dog(1),new Dog(3),new Dog(2)};
Sorter sorter = new Sorter<>();
// sorter.sort(a,new CatWeightComparator());
sorter.sort(a,new CatheightComparator());
System.out.println(Arrays.toString(a));
}
}
测试结果：
5.3 总结
当一个类有多种行为时，后期可能还会增加行为时，我们可以将每一种行为封装起来使其能够相互替换。如我们要出么去一个目的地，可使用的工具有自驾汽车、打车、公交、骑车，未来可能还有地铁等方式，这时每一种出行方式就是一种我们出门的行为，将每种行为封装起来，我们想使用什么方式时就可以调出对应的方式。
优点：
- 可以随意切换行为
- 拓展性强，如有新的行为很好添加
- 省去一些不必要重复的判断
缺点：
- 如果策略非常多时，暴露出来的类也会非常多