第 25 章策略模式

缺乏、安全感 2022-12-12 13:55 251阅读 0赞

# 第 25 章 策略模式 #

## 1、编写鸭子项目 ##

编写鸭子项目，具体要求如下:

1.  有各种鸭子(比如野鸭、北京鸭、水鸭等， 鸭子有各种行为，比如叫、飞行等)
2.  显示鸭子的信息

## 2、传统方案解决鸭子问题 ##

> **传统方案解决方案**

类图

![image-20200901090735414][]

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

代码实现

1.  `Duck`：鸭子的抽象父类
    
        public abstract class Duck {
              
        
        	public Duck() {
              
        
        	}
        
        	public abstract void display();// 显示鸭子信息
        
        	public void quack() {
              
        		System.out.println("鸭子嘎嘎叫~~");
        	}
        
        	public void swim() {
              
        		System.out.println("鸭子会游泳~~");
        	}
        
        	public void fly() {
              
        		System.out.println("鸭子会飞翔~~~");
        	}
        
        }
2.  `WildDuck`：野鸭
    
        public class WildDuck extends Duck {
              
        
        	@Override
        	public void display() {
              
        		System.out.println(" 这是野鸭 ");
        	}
        
        }
3.  `PekingDuck`：北京烤鸭
    
        public class PekingDuck extends Duck {
              
        
        	@Override
        	public void display() {
              
        		System.out.println("~~北京鸭~~~");
        	}
        
        	// 因为北京鸭不能飞翔，因此需要重写fly
        	@Override
        	public void fly() {
              
        		System.out.println("北京鸭不能飞翔");
        	}
        
        }
4.  `ToyDuck`；玩具鸭鸭
    
        public class ToyDuck extends Duck {
              
        
        	@Override
        	public void display() {
              
        		System.out.println("玩具鸭");
        	}
        
        	// 需要重写父类的所有方法
        	public void quack() {
              
        		System.out.println("玩具鸭不能叫~~");
        	}
        
        	public void swim() {
              
        		System.out.println("玩具鸭不会游泳~~");
        	}
        
        	public void fly() {
              
        		System.out.println("玩具鸭不会飞翔~~~");
        	}
        }

> **传统的方式实现的问题分析和解决方案**

1.  其它鸭子，都继承了`Duck` 类，所以 `fly` 让所有子类都会飞了，这是不正确的
2.  上面说的问题，其实是继承带来的问题： 对类的局部改动，尤其超类的局部改动，会影响其他部分，会有溢出效应
3.  为了改进此问题，我们可以通过覆盖 `fly` 方法来解决 ==> 覆盖解决
4.  问题又来了，如果我们有一个玩具鸭子`ToyDuck`，这样就需要`ToyDuck`去覆盖`Duck`的所有实现的方法 ==> 解决思路 ：策略模式 (`strategy pattern`)

## 3、策略模式基本介绍 ##

1.  策略模式(`Strategy Pattern`)中，定义算法族(策略簇)，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
2.  这算法体现了几个设计原则：
    
    1.  第一、把变化的代码从不变的代码中分离出来；
    2.  第二、针对接口编程而不是具体类(定义了策略接口)；
    3.  第三、多用组合(或聚合)，少用继承(客户通过组合方式使用策略)

## 4、策略模式的原理类图 ##

从图中可以看到， 客户 `context` 有成员变量 `strategy` 或者其他的策略接口，至于需要使用到哪个策略， 我们可以在构造器中指定

![image-20200901092021500][]

## 5、策略模式解决鸭子问题 ##

应用实例要求

编写程序完成前面的鸭子项目， 要求使用策略模式

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

类图

策略模式： 分别封装行为接口， 实现算法族， 超类里放行为接口对象， 在子类里具体设定行为对象。 原则就是：分离变化部分， 封装接口， 基于接口编程各种功能。 此模式让行为的变化独立于算法的使用者

![image-20200901130821800][]

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

代码实现

1.  `FlyBehavior`：飞行的行为(算法的提供者)
    
        public interface FlyBehavior {
              
        	void fly(); // 子类具体实现
        }
2.  `NoFlyBehavior`：
    
        public class NoFlyBehavior implements FlyBehavior {
              
        
        	@Override
        	public void fly() {
              
        		System.out.println(" 不会飞翔  ");
        	}
        
        }
3.  `BadFlyBehavior`：
    
        public class BadFlyBehavior implements FlyBehavior {
              
        
        	@Override
        	public void fly() {
              
        		System.out.println(" 飞翔技术一般 ");
        	}
        
        }
4.  `GoodFlyBehavior`：
    
        public class GoodFlyBehavior implements FlyBehavior {
              
        
        	@Override
        	public void fly() {
              
        		System.out.println(" 飞翔技术高超 ~~~");
        	}
        
        }
5.  `QuackBehavior`：叫的行为(算法的提供者)
    
        public interface QuackBehavior {
              
        	void quack();// 子类实现
        }
6.  `NoQuackBehavior`：
    
        public class NoQuackBehavior implements QuackBehavior {
              
        
        	@Override
        	public void quack() {
              
        		System.out.println("不能叫");
        	}
        
        }
7.  `GeGeQuackBehavior`：
    
        public class GeGeQuackBehavior implements QuackBehavior {
              
        
        	@Override
        	public void quack() {
              
        		System.out.println("咯咯叫");
        	}
        
        }
8.  `GaGaQuackBehavior`：
    
        public class GaGaQuackBehavior implements QuackBehavior {
              
        
        	@Override
        	public void quack() {
              
        		System.out.println("嘎嘎叫");
        	}
        
        }
9.  `Duck`：鸭子的抽象父类(算法的使用者)，通过聚合不同的行为对象(算法的提供者)，实现不同的行为模式
    
        public abstract class Duck {
              
        
        	// 属性, 策略接口
        	FlyBehavior flyBehavior;
        	// 其它属性<->策略接口
        	QuackBehavior quackBehavior;
        
        	public Duck() {
              
        
        	}
        
        	public abstract void display();// 显示鸭子信息
        
        	public void quack() {
              
        		if (quackBehavior != null) {
              
        			quackBehavior.quack();
        		}
        	}
        
        	public void swim() {
              
        		System.out.println("鸭子会游泳~~");
        	}
        
        	public void fly() {
              
        		// 改进
        		if (flyBehavior != null) {
              
        			flyBehavior.fly();
        		}
        	}
        
        	public void setFlyBehavior(FlyBehavior flyBehavior) {
              
        		this.flyBehavior = flyBehavior;
        	}
        
        	public void setQuackBehavior(QuackBehavior quackBehavior) {
              
        		this.quackBehavior = quackBehavior;
        	}
        
        }
10. `WildDuck`：
    
        public class WildDuck extends Duck {
              
        
        	// 构造器，传入FlyBehavior 和 QuackBehavior 的对象
        	public WildDuck() {
              
        		flyBehavior = new GoodFlyBehavior();
        		quackBehavior = new GeGeQuackBehavior();
        	}
        
        	@Override
        	public void display() {
              
        		System.out.println(" 这是野鸭 ");
        	}
        
        }
11. `PekingDuck`：
    
        public class PekingDuck extends Duck {
              
        
        	// 假如北京鸭可以飞翔，但是飞翔技术一般
        	public PekingDuck() {
              
        		flyBehavior = new BadFlyBehavior();
        		quackBehavior = new GaGaQuackBehavior();
        	}
        
        	@Override
        	public void display() {
              
        		System.out.println("~~北京鸭~~~");
        	}
        
        }
12. `ToyDuck`：
    
        public class ToyDuck extends Duck {
              
        
        	public ToyDuck() {
              
        		flyBehavior = new NoFlyBehavior();
        		quackBehavior = new NoQuackBehavior();
        	}
        
        	@Override
        	public void display() {
              
        		System.out.println("玩具鸭");
        	}
        
        	public void swim() {
              
        		System.out.println("玩具鸭不会游泳~~");
        	}
        
        }
13. `Client`：测试代码
    
        public class Client {
              
        
        	public static void main(String[] args) {
              
        		WildDuck wildDuck = new WildDuck();
        		wildDuck.fly();
        
        		ToyDuck toyDuck = new ToyDuck();
        		toyDuck.fly();
        
        		PekingDuck pekingDuck = new PekingDuck();
        		pekingDuck.fly();
        
        		// 动态改变某个对象的行为, 北京鸭 不能飞
        		pekingDuck.setFlyBehavior(new NoFlyBehavior());
        		System.out.println("北京鸭的实际飞翔能力");
        		pekingDuck.fly();
        	}
        
        }

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

总结：将原来的继承方式改为组合(或聚合)方式，来实现对象的行为，可以将算法的使用者(`Dick`)与算法的提供者(`FlyBehavior` 和 `QuackBehavior`)解耦

## 6、JDK Arrays 源码分析 ##

代码

public class Strategy {
        
    
    	public static void main(String[] args) {
        
    		// TODO Auto-generated method stub
    		// 数组
    		Integer[] data = {
         9, 1, 2, 8, 4, 3 };
    		// 实现降序排序，返回-1放左边，1放右边，0保持不变
    
    		// 说明
    		// 1. 实现了 Comparator 接口（策略接口） , 匿名类 对象 new Comparator<Integer>(){..}
    		// 2. 对象 new Comparator<Integer>(){..} 就是实现了 策略接口 的对象
    		// 3. public int compare(Integer o1, Integer o2){} 指定具体的处理方式
    		Comparator<Integer> comparator = new Comparator<Integer>() {
        
    			public int compare(Integer o1, Integer o2) {
        
    				if (o1 > o2) {
        
    					return -1;
    				} else {
        
    					return 1;
    				}
    			};
    		};
    		
    		// 说明
    		/*
    		 * public static <T> void sort(T[] a, Comparator<? super T> c) {
    		        if (c == null) {
    		            sort(a); //默认方法
    		        } else { 
    		            if (LegacyMergeSort.userRequested)
    		                legacyMergeSort(a, c); //使用策略对象c
    		            else
    		            	// 使用策略对象c
    		                TimSort.sort(a, 0, a.length, c, null, 0, 0);
    		        }
    		    }
    		 */
    		//方式1 
    		Arrays.sort(data, comparator);
    
    		System.out.println(Arrays.toString(data)); // 降序排序
    
    		// 方式2- 同时lambda 表达式实现 策略模式
    		Integer[] data2 = {
         19, 11, 12, 18, 14, 13 };
    
    		Arrays.sort(data2, (var1, var2) -> {
        
    			if (var1.compareTo(var2) > 0) {
        
    				return -1;
    			} else {
        
    				return 1;
    			}
    		});
    
    		System.out.println("data2=" + Arrays.toString(data2));
    
    	}
    
    }

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

总结

`Comparator` 为策略接口(算法的提供者)，其实现对象指明了具体算法的行为，`Arrays` 为算法的使用者，通过组合(聚合)不同的算法提供者，实现不同的算法行为

## 7、策略模式的注意事项和细节 ##

1.  策略模式的关键是： 分析项目中变化部分与不变部分
2.  策略模式的核心思想是：多用组合(聚合)，少用继承；用行为类组合，而不是行为的继承，这样更有弹性
3.  体现了“对修改关闭，对扩展开放”原则，客户端增加行为不用修改原有代码，只要添加一种策略（或者行为）即可， 避免了使用多重判断语句（`if..else if..else`）
4.  提供了可以替换继承关系的办法： 策略模式将算法封装在独立的`Strategy`类中使得你可以独立于其`Context`改变它，使它易于切换、易于理解、易于扩展
5.  需要注意的是：每添加一个策略就要增加一个类，当策略过多时，会导致类数目庞大

[image-20200901090735414]: /images/20221123/8f0f99916dfc43bfae98f4b67623dddc.png
[image-20200901092021500]: /images/20221123/bb04a132773a4f72a4531370c7e18ef2.png
[image-20200901130821800]: /images/20221123/3a7f949298914745b7f3c7e2ae381306.png