JAVA设计模式策略模式

JAVA设计模式--策略模式

--采用了面向对象的继承和多态

 

引入:在软件开发中常常遇到这种情况，实现某一个功能有多种算法或者策略，我们可以根据环境或者条件的不同选择不同的算法或者策略来完成该功能。如查找、排序等，一种常用的方法是硬编码(Hard Coding)在一个类中，如需要提供多种查找算法，可以将这些算法写到一个类中，在该类中提供多个方法，每一个方法对应一个具体的查找算法；当然也可以将这些查找算法封装在一个统一的方法中，通过if…else…或者case等条件判断语句来进行选择。

这两种实现方法我们都可以称之为硬编码，如果需要增加一种新的查找算法，需要修改封装算法类的源代码；更换查找算法，也需要修改客户端调用代码。在这个算法类中封装了大量查找算法，该类代码将较复杂，维护较为困难。如果我们将这些策略包含在客户端，这种做法更不可取，将导致客户端程序庞大而且难以维护，如果存在大量可供选择的算法时问题将变得更加严重。

 

问题:

如何让算法和对象分开来，使得算法可以独立于使用它的客户而变化？

 

方案:

把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口，然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。

比如定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换，使得算法可独立于使用它的客户而变化。这就是策略模式。

 

适用情况:

许多相关的类仅仅是行为有异。 “策略”提供了一种用多个行为中的一个行为来配置一个类的方法。即一个系统需要动态地在几种算法中选择一种。

当一个应用程序需要实现一种特定的服务或者功能，而且该程序有多种实现方式时使用。

一个类定义了多种行为 , 并且这些行为在这个类的操作中以多个条件语句的形式出现。将相关的条件分支移入它们各自的Strategy类中以代替这些条件语句。

 

优点:

1、可以动态的改变对象的行为

缺点:

1、客户端必须知道所有的策略类，并自行决定使用哪一个策略类

2、策略模式将造成产生很多策略类

 

组成:

环境类(Context):用一个ConcreteStrategy对象来配置。维护一个对Strategy对象的引用。可定义一个接口来让Strategy访问它的数据。

抽象策略类(Strategy):定义所有支持的算法的公共接口。 Context使用这个接口来调用某ConcreteStrategy定义的算法。

具体策略类(ConcreteStrategy):以Strategy接口实现某具体算法。

 

应用:comparable和comparator的应用

测试类:比较两只毛的大小,一个是高度,另一个是体重.

package com_java_singleton;
//现在比较大小的方式是固定的
//我们思考  给对象排序时 能够灵活的比较(以不确定的方式)
//考虑多态进行扩展
public class Test {
    public static void main(String[] args) {
        Cat[] a={new Cat(6,6),new Cat(5,5),new Cat(4,4),new Cat(6,6)};
        //java.util.Arrays.sort(a);
        DateSorter.sort(a);
        DateSorter.p(a);
    }
}

逻辑实现排序

public class DateSorter {
    //如果要求对所有类型的排序,所以可以使用object
    //比较大小的
    public static void sort(Object[] a) {
        for (int i = a.length; i >0; i--) {
            for (int j = 0; j < i-1; j++) {
                Comparable o1=(Comparable) a[j];
                Comparable o2=(Comparable) a[j+1];
                if(o1.compareTo(o2)==1){
                     swap(a,j,j+1);
                }
            }
        }
    }

    private static void swap(Object[] a, int j, int i) {
        // TODO Auto-generated method stub
        Object temp=a[j];
        a[j]=a[i];
        a[i]=temp;
    }
    
    public static void p(Object[] a) {
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]+" ");
        }
    }

}

接口类comparable和comparator

public interface Comparable {
    int  compareTo(Object o);
}

public interface Comparator {
    int compare(Object o1,Object o2);
}

cat实现

public class Cat implements Comparable{
    //生产构造方法,指定大小
    public Cat(int height, int weight) {
        super();
        this.height = height;
        this.weight = weight;
    }

    private int height;
    private int weight;
    public int getHeight() {
        return height;
    }
    
    public void setHeight(int highly) {
        this.height = highly;
    }
    public int getWeight() {
        return weight;
    }
    public void setWeight(int weight) {
        this.weight = weight;
    }
    
    @Override
    public String toString() {
        return "Cat [height=" + height + ", weight=" + weight + "]";
    }
    //成员变量  比较器类型
    private Comparator comparator=new CatHeightComparator();
    
    public Comparator getComparator() {
        return comparator;
    }

    public void setComparator(Comparator comparator) {
        this.comparator = comparator;
    }

    @Override
    public int compareTo(Object o) {
        /*// TODO Auto-generated method stub
        if(o instanceof Cat){
            Cat c=(Cat) o;
            if(this.getHeight()>c.getHeight()) return 1;
            else return -1;
        }
        //若果不是猫,可以抛异常
        return 0;*/
        return comparator.compare(this, o);
    }
}

 

参考:https://blog.csdn.net/jason0539/article/details/45007553