デザインパターン-----戦略パターン

戦略モード

定義

いわゆる戦略は、アルゴリズムのモデルファミリーの定義であり、彼らは前に相互に変換することができるように、それらをカプセル化し、このモデルは、アルゴリズムの変更は、アルゴリズムクライアントの使用とは独立していることができます

理解

ワード戦略は私たちは、このような自転車に乗って、移動する別の方法を選択します外出時、話すこと、理解してどのようにする必要があり、そのそれぞれは、その上にこれらの走行モードをバス、電車、飛行機、ロケットに乗ると、戦略

私たちはショッピングモールに行く別の例は、商店街が今の活動に従事され、割引があり、フルカットがあり、リベートがあるというように、実際には、関係なく、モールのプロモーションの、最終的な分析では、それ自体が唯一の戦術であるいくつかのアルゴリズムですそしてこれらのアルゴリズムは互換性があり、これらの戦略の中で、少なくとも、例えば、商品の同じ部分について、二十%今日の割引、明日100 30によって、いつでも交換可能です

UMLのクラス図

これは、コンテキストが戦略オブジェクトへの参照を維持し、構成するConcreteStrategyと、コンテキストである戦略は、すべてのサポートされているアルゴリズムのための共通のインタフェースを定義するポリシー・クラスである。ConcreteStrategy特定戦略、特定のアルゴリズム又は行動のパッケージ、継承戦略で

説明

1.Contextコンテキスト

また、コンテキストパッケージの役割と呼ばれるコンテキストのコンテキストの役割は、戦略にモジュールダイレクトアクセスシールド層を接続する役割を果たし、このアルゴリズムは、パッケージの変更があるかもしれません

public class Context {

    Strategy strategy;

    public Context(Strategy strategy){
        this.strategy = strategy;
    }

    /**
     * 上下文接口
     */
    public void contextInterface(){
        strategy.algorithmInterface();
    }
}

2.Strategy戦略の役割

抽象的な政策の役割は、戦略、抽象的アルゴリズムの家族は、通常、インターフェイスのメソッドとプロパティを持っている必要があり、それぞれの戦略やアルゴリズムを定義しています。このアルゴリズムは、「アルゴリズム」手段であり、

public interface Strategy {
    /**
     * 算法方法
     */
    public void algorithmInterface();
}

3.具体的な政策の役割

特定のアルゴリズムを達成するために、即ち、ポリシーを実装するための抽象操作は、底部がプリントで置き換えました。3 ConcreteStrategy、他の2つのクラスのテストカテゴリConcreteStrategyA同様に、繰り返さないであろう

class ConcreteStrategyA implements Strategy{

    @Override
    public void algorithmInterface() {
        System.out.println("策略A的具体算法实现");
    }
}

4.Clientクライアント

次の戦略の交換に続いて、テスト戦略モード

public class StrategyClient {
    public static void main(String[] args) {
        Context context;

        context = new Context(new ConcreteStrategyA());
        context.contextInterface();

        context = new Context(new ConcreteStrategyB());
        context.contextInterface();

        context = new Context(new ConcreteStrategyC());
        context.contextInterface();
    }
}

結果は以下の通りであります：

例1：

私たちは皆、多くのソートアルゴリズムがあることを知っているが、バブルソート、選択するための選択ソートを選択するとき、とき、ので、ここでのソートアルゴリズムが実装戦略のモードを実証するために使用される挿入ソートを選択するために、

public void selectSort(String type){
        if("type1".equals(type)){
            //选择快速排序
        }
        else if("type2".equals(type)){
            //选择插入排序
        }
        else if("type3".equals(type)){
            //选择冒泡排序
        }
        else if("type4".equals(type)){
            //选择选择排序
        }
        ......
    }

ソートモジュールを変更すると、変更する必要があるかもしれないがあればシステムの場合、他のこのようなコードの実現、場合の膨大な数に加えて、コード... ...他に、プログラムの貧弱な保守性が得られ、かつ拡張性のために、良いではありませんソースコード。したがって、このようなシナリオのための戦略パターンを使用して、それは非常に適切です。

それでは、どのように、ここでの戦略パターンを使用していますか？まず、その後、インターフェースが可能実装するソートアルゴリズムを定義し、ソートアルゴリズムを提供するインタフェースを定義する必要があります。次のように：

最初のソートアルゴリズムを定義ソートインターフェースである、ソートアルゴリズムの全ては、このインタフェースを実装する必要があります

public interface Sort{
    public abstract int[] sort(int arr[]);
}

そして、3つの特定のソートアルゴリズム、彼らはソート・インタフェースを実現します。

バブルソート：BubbleSort.java

public class BubbleSort implements Sort{
    public int[] sort(int arr[]){
       int len=arr.length;
       for(int i=0;i<len;i++){
           for(int j=i+1;j<len;j++){
              int temp;
              if(arr[i]>arr[j]){
                  temp=arr[j];
                  arr[j]=arr[i];
                  arr[i]=temp;
              }             
           }
        }
        System.out.println("冒泡排序");
        return arr;
    }
}

挿入ソート：InsertionSort.java

public class InsertionSort implements Sort {
    public int[] sort(int arr[]) {
        int len = arr.length;
        for (int i = 1; i < len; i++) {
            int j;
            int temp = arr[i];
            for (j = i; j > 0; j--) {
                if (arr[j - 1] > temp) {
                    arr[j] = arr[j - 1];

                } else
                    break;
            }
            arr[j] = temp;
        }
        System.out.println("插入排序");
        return arr;
    }
}

選択並べ替え：SelectSort.java

public class SelectionSort implements Sort {
    public int[] sort(int arr[]) {
        int len = arr.length;
        int temp;
        for (int i = 0; i < len; i++) {
            temp = arr[i];
            int j;
            int samllestLocation = i;
            for (j = i + 1; j < len; j++) {
                if (arr[j] < temp) {
                    temp = arr[j];
                    samllestLocation = j;
                }
            }
            arr[samllestLocation] = arr[i];
            arr[i] = temp;
        }
        System.out.println("选择排序");
        return arr;
    }
}

最後のカテゴリは、クライアントをテストすることですClient.java

public class ArrayHandler
{
    private Sort sortObj;
    
    public int[] sort(int arr[])
    {
        sortObj.sort(arr);
        return arr;
    }

    public void setSortObj(Sort sortObj) {
        this.sortObj = sortObj; 
    }
}

public class Client
{
    public static void main(String args[])
    {
       int arr[]={1,4,6,2,5,3,7,10,9};
       int result[];
       ArrayHandler ah=new ArrayHandler();
       
       Sort sort = new SelectionSort();    //使用选择排序
       
       ah.setSortObj(sort); //设置具体策略
       result=ah.sort(arr);
       
       for(int i=0;i<result.length;i++)
       {
               System.out.print(result[i] + ",");
       }
    }
}

結果：

選択ソート

1,2,3,4,5,6,7,9,10、

例2：

店舗のプロモーションアルゴリズムを達成するための戦略パターンを使用するには、例えばストアプロモーション、

1.コンテキストクラス

　　まず、異なる料金ポリシーについて得られた結果に基づいて、計算の特定の価格戦略、関数のgetResult（）メソッドを渡し、コンストラクタを介しCashSuperオブジェクトを宣言する。

public class CashContext {
    
    private CashSuper cashSuper;
    
    public CashContext(CashSuper cashSuper) {
        this.cashSuper = cashSuper;
    }
    
    public double getResult(double money) {
        return cashSuper.acceptCash(money);
    }

}

2.ペイ現金抽象クラス

　　ポリシークラス、抽象クラス、サブクラスの実装を充電するための抽象メソッド。

public abstract class CashSuper {
    
    public abstract double acceptCash(double money);

}

3.通常の料金のサブクラス

　　アクティブの場合、通常料金は、元の価格を返しません。

public class CashNormal extends CashSuper {

    @Override
    public double acceptCash(double money) {
        return money;
    }
}

4.割引料金サブクラス

　　割引は、リターンの割引価格に基づいて割り引か。

public class CashRebate extends CashSuper {
    
    private double moneyRebate = 1;    //折扣
    
    public CashRebate(double moneyRebate) {
        this.moneyRebate = moneyRebate;
    }

    @Override
    public double acceptCash(double money) {
        return money * moneyRebate;
    }
}

リベート充電サブクラス

　　リベート活動、入力条件とリベートリベート値、例えばバック100に少なくとも300、300 moneyCoditation、moneyReturn 100。

　　結果=お金 - Math.floor（お金/ moneyConditation）* moneyReturnは、現在の電流値を減算することにより割戻額を使用して、リベート等しい条件の量よりも大きい場合、ということを意味します

public class CashReturn extends CashSuper {

    private double moneyConditation = 0.0;    //返利条件
    private double moneyReturn = 0.0d;    //返利值
    
    public CashReturn(double moneyConditation, double moneyReturn) {
        this.moneyConditation = moneyConditation;
        this.moneyReturn = moneyReturn;
    }

    @Override
    public double acceptCash(double money) {
        double result = money;
        
        if (money >= moneyConditation) {
            result = money - Math.floor(money / moneyConditation) * moneyReturn;
        }
        
        return result;
    }
}

6.クライアントクライアント

　　以下は、上記の記述されたコードをテストするための簡単なプログラムを書きます。

 public class Client {
    
    public static void main(String[] args) {
        CashContext cashContext = null;
        
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入打折方式（1/2/3）：");
        int in = scanner.nextInt();
        String type = "";
        
        switch (in) {
            case 1:
                cashContext = new CashContext(new CashNormal());
                type += "正常收费";
                break;
                
            case 2:
                cashContext = new CashContext(new CashReturn(300, 100));
                type += "满300返100";
                break;
                
            case 3:
                cashContext = new CashContext(new CashRebate(0.8));
                type += "打8折";
                break;
    
            default:
                System.out.println("请输入1/2/3");
                break;
        }
        
        double totalPrices = 0;
        
        System.out.print("请输入单价：");
        double price = scanner.nextDouble();
        System.out.print("请输入数量：");
        double num = scanner.nextDouble();
        totalPrices = cashContext.getResult(price * num);
        
        System.out.println("单价：" + price + "，数量：" + num + "，类型：" + type + "，合计：" + totalPrices);
        
        scanner.close();
    }

}

次のように通常の手数料は以下のとおりです。

アプリケーション

1.使用します

• システムは、クラスの数を持っており、それらにだけ彼らの即時の行動を区別する場合

2.方法

• クラスのパッケージ、または任意の代替にこれらのアルゴリズム

3.利点

• アルゴリズムは自由に切り替えることができます
• 条件付きの複数使用しないでください（私たちは、複数の条件文を使用することがポリシーモードでない場合は、メンテナンスに助長されていません）
• 扩展性良好，增加一个策略只需实现接口即可

4.缺点

• 策略类数量会增多，每个策略都是一个类，复用的可能性很小
• 所有的策略类都需要对外暴露

5.使用场景

• 多个类只有算法或行为上稍有不同的场景
• 算法需要自由切换的场景
• 需要屏蔽算法规则的场景

6.应用实例

• 出行方式，自行车、汽车等，每一种出行方式都是一个策略
• 商场促销方式，打折、满减等
• Java AWT中的LayoutManager，即布局管理器

7.注意事项

• 如果一个系统的策略多于四个，就需要考虑使用混合模式来解决策略类膨胀的问题