引入
- 大家先考虑一个场景, 有一个整形数组, 我们希望通过调用一个工具类的排序方法就能对该数组进行排序. 请看下面的代码:
public class Strategy {
public static void main(String[] args) {
int[] arr = {5, 3, 1, 7, 2};
new DataSorter().sort(arr);
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
class DataSorter{
public void sort(int[] arr){
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
if(arr[j] > arr[j + 1])
swap(arr, j, j + 1);
}
}
}
private void swap(int[] arr, int i, int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
Comparable接口的来龙去脉
- 通过上面的代码, 我们能够轻易地对整形数组进行排序, 那么如果现在有了新需求, 需要对浮点类型数据进行排序, 排序工具类应该如何做呢?
- 或许你会想, 不如就新添加一个排序方法, 方法的参数类型为
float类型, 把int类型数组的排序算法复制一遍不就可以了吗?
- 那如果我继续追问, 如果现在要对一只猫进行排序, 那应该怎么做呢? 猫的类如下
class Cat{
private int age;
private int weight;
}
- 你也许会顺着原来的思路回答, 照样copy一份排序的算法, 修改方法参数, 然后在比较的地方指定比较猫的年龄或体重不就可以了吗?
public void sort(Cat[] arr){
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
if(arr[j].getAge() > arr[j + 1].getAge())
swap(arr, j, j + 1);
}
}
}
- 但仔细想想, 如果还要继续比较小狗, 小鸡, 小鸭等各种对象, 那么这个排序工具类的代码量岂不是变得很大? 为了能让排序算法的可重用性高一点, 我们希望排序工具中的
sort()方法可以对任何调用它的对象进行排序.
- 你可能会想: 到对任何对象都能排序, 把
sort()方法的参数改为Object类型不久可以了嘛. 这个方向是对的, 但是问题是, 当拿到两个Object类型对象, 应该根据什么规则进行比较呢?
- 这个时候我们自然而然地就希望调用工具类进行排序的对象本身就具备自己的
比较法则, 这样在排序的时候就能直接调用对象的排序法则进行排序了.
- 我们把比较法则抽象为
Comparable接口, 凡是要进行比较的类都要实现Comparable接口, 并且定义自己的比较法则, 也就是CompareTo()方法.
- 这样当我们在封装工具时, 就可以直接对实现了
Comparable接口的对象进行比较, 不用担心比较的细节了.
public class Strategy {
public class Strategy {
public static void main(String[] args) {
Cat[] arr = {new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)};
DataSorter ds = new DataSorter();
ds.sort(arr);
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
}
class DataSorter{
public void sort(Object[] arr){
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
Comparable c1 = (Comparable) arr[j];
Comparable c2 = (Comparable) arr[j + 1];
if(c1.CompareTo(c2) == 1)
swap(arr, j, j + 1);
}
}
}
private void swap(Object[] arr, int i, int j){
Object temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
class Cat implements Comparable{
private int age;
private int weight;
@Override
public int CompareTo(Object o) {
if(o instanceof Cat){
Cat c = (Cat) o;
if(this.age > c.age) return 1;
else if (this.age < c.age) return -1;
else return 0;
}
throw null == o ? new NullPointerException() : new ClassCastException();
}
}
interface Comparable{
public int CompareTo(Object o);
}
引入Comparator接口
- 相信看了上面的
Comparable接口来由, 大家会感觉整个设计又美好了一些, 但是其中还有漏洞. 我们在Cat类的CompareTo()方法中, 对猫的比较策略是写死的, 现在我们按猫的年龄比较大小, 如果哪天我们想按照猫的体重比较大小, 又要去修改源码了. 有没有扩展性更好的设计?
- 我们可以让用户自己定义一个比较器类, 对象可以根据用户指定的比较器比较大小.
- 整个逻辑是: 如果这个对象需要进行比较, 那么它必须实现
Comparable接口, 但是它具体是怎么比较的, 则通过具体的Comparator比较器进行比较.
- 当然这里少不了多态, 我们首先要定义一个比较器接口
Comparator, 用户的比较器需要实现Comparator接口, 下面上代码:
public class Strategy {
public static void main(String[] args) {
Cat[] arr = {new Cat(3, 3), new Cat(1, 1), new Cat(5, 5)};
DataSorter ds = new DataSorter();
ds.sort(arr);
for(int i = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
class DataSorter{
public void sort(Object[] arr){
for(int i = arr.length - 1; i > 0; i--){
for(int j = 0; j < i; j++){
Comparable c1 = (Comparable) arr[j];
Comparable c2 = (Comparable) arr[j + 1];
if(c1.CompareTo(c2) == 1)
swap(arr, j, j + 1);
}
}
}
private void swap(Object[] arr, int i, int j){
Object temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
class Cat implements Comparable{
private int age;
private int weight;
private Comparator comparator = new CatAgeComparator();
@Override
public int CompareTo(Object o) {
return comparator.Compare(this, o);
}
}
interface Comparable{
public int CompareTo(Object o);
}
interface Comparator{
public int Compare(Object o1, Object o2);
}
class CatAgeComparator implements Comparator{
@Override
public int Compare(Object o1, Object o2) {
Cat c1 = (Cat) o1;
Cat c2 = (Cat) o2;
if(c1.getAge() > c2.getAge()) return 1;
else if(c1.getAge() < c2.getAge()) return -1;
else return 0;
}
}
class CatWeightComparator implements Comparator{
@Override
public int Compare(Object o1, Object o2) {
Cat c1 = (Cat) o1;
Cat c2 = (Cat) o2;
if(c1.getWeight() > c2.getWeight()) return 1;
else if(c1.getWeight() < c2.getWeight()) return -1;
else return 0;
}
}
什么是策略模式?
- 在上面的例子中, 我们自己定义了
Comparable接口和Comparator接口, 其实这两个接口都是Java自带的, 通过上面的代码示例, 想必大家也应该知道了为什么会有这两个接口.
- 其实
Comparable定义的就是一种比较的策略, 这里的策略你可以理解为一个功能, 然而策略有了, 我们还需要有具体的策略实现, 于是便有了Comparator接口.
- 这里再举一个例子方便大家理解.
- 现在有一个坦克小游戏, 坦克要能够发射炮弹, 那么我们可以认为发射炮弹就是一种策略, 但是具体到发送什么炮弹, 这可以由具体的策略实现.
- 到GitHub上看看该坦克游戏
- 首先定义发射炮弹这种策略
public interface Fire {
public void fire();
}
- 为了实现发射炮弹这种策略, 定义策略的具体实现, 也就是定义发射炮弹动作
public interface FireAction {
public void fireAction(Tank tank);
}
- 坦克想要发送炮弹必须实现
Fire()接口, 而且坦克拥有发射炮弹的动作, 至于动作的具体实现, 这里默认给出只发射一颗炮弹的动作.
public class Tank implements TankHitListener, Fire {
private FireAction fireAction = new NormalFireAction();
@Override
public void fire() {
fireAction.fireAction(this);
}
使用了策略模式有什么好处?
- 以上面的坦克游戏为例, 当把发射炮弹定义为一种策略后, 能发射炮弹的对象就不只坦克一个了, 如果游戏中有机关, 可以让机关也实现
fire()接口, 获得发射炮弹的能力.
- 而且在定义策略后我们可以根据策略给出不同的实现方式, 比方说坦克发射炮弹的动作是每次只发射一颗炮弹, 而机关是每次向八个方向发射一颗炮弹. 非常灵活.
- 结束
往期推荐：
- 写代码解释什么是api，什么是sdk
- 飞机大战小游戏全制作过程分享
- 仿flappy bird小游戏制作分享
- 如何开始编写技术博客？markdown语法入门，分享使人进步
