北风设计模式课程---策略模式与简单工厂模式的结合使用

一、总结

一句话总结：

不仅要通过视频学，还要看别的博客里面的介绍，搜讲解，搜作用，搜实例

1、实现简易计算器可以用策略模式么？

很好的选择：用为那些不同的符号操作就相当于并列的不同的算法

二、策略模式与简单工厂模式的结合使用

转自或参考：策略模式与简单工厂模式的结合使用
https://www.cnblogs.com/zhi-hao/p/4025981.html

　　Java设计模式中的策略模式（Strategy Patten）定义了一组算法，将每个算法都封装起来，并且可使它们之间可以相互替换，在客户端调用它们时可以互不影响。

策略模式主要由三个角色组成

1、抽象策略角色：通常是一个接口或抽象类实现，我们的具体策略类就是继承或实现这个抽象角色。

2、具体策略角色：我们在这些类中写策略和算法，继承或实现抽象策略角色。

3、环境角色：环境角色中拥有一个抽象策略角色的引用，供客户端调用，该角色把客户端跟策略类的实现分离。

从上面的三个策略模式的角色中，我们就大概可以知道策略模式的编写步骤,这里以实现简单的四则运算为例。

1、定义抽象策略角色，也就是定义一个公共的抽象类（也可以是接口）

1  パッケージ戦略;
 2  / ** 
3  * 
 4  * @authorのCIACs
 。5  *抽象ポリシーの役割を定義する
 。6   * / 
7  パブリック 抽象 クラス戦略{
 8。     // 抽象ポリシー・メソッドを定義する
9。     パブリック 抽象 int型の戦略（INT A、INTのB） ;
 10  
11 }

2、上記で定義された抽象クラスを実装するポリシークラスを書きます

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  * AddStrategy
 6  */
 7 public class AddStrategy extends Strategy {
 8     //定义实现加法的策略方法
 9     public int strategy(int a, int b)
10     {
11         return a+b;
12     }
13 
14 }

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    SubStrategy
 6  */
 7 public class SubStrategy extends Strategy {
 8     //定义减法的策略方法
 9     public int strategy(int a, int b)
10     {
11         return a-b;
12     }
13 
14 }

1  パッケージ戦略;
 2  / ** 
3  * 
 4  * @authorのCIACs
 。5  * MultiplyStrategy
 。6   * / 
7  パブリック クラス MultiplyStrategy 延び戦略{
 8。     // 乗算を定義されたポリシー・メソッドを
9。     公共の int型の戦略（int型 A、int型B）の
 10      {
 11。         戻り *のBを、
 12である     }
 13です }

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    DivStrategy
 6  */
 7 public class DivStrategy extends Strategy {
 8     //定义除法的策略方法，这里为了简单就不考虑除数为零的情况了
 9     public int strategy(int a,int b)
10     {
11         return a/b;
12     }
13 }

3、编写环境角色，其中持有一个抽象策略类的引用

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Context
 6  */
 7 public class Context {
 8     //持有抽象策略角色的引用，用于客户端调用
 9     private Strategy strategy;
10     //获得策略类
11     public Strategy getStrategy() {
12         return strategy;
13     }
14     //设置所需策略
15     public void setStrategy(Strategy strategy) {
16         this.strategy = strategy;
17         
18     }
19     //根据设置的策略类返回对应的结果
20     public int getResult(int a,int b)
21     {
22         return strategy.strategy(a, b);
23     }
24 
25 }

4、编写客户端

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Client
 6  */
 7 public class Client {
 8     public static void main(String[] args) {
 9         
10         Context context = new Context();
11         
12         int result;
13         
14         context.setStrategy(new SubStrategy());
15         
16         result = context.getResult(9, 3);
17         
18         System.out.println("sub: "+result);
19         
20         context.setStrategy(new AddStrategy());
21         
22         result =context.getResult(9, 3);
23         
24         System.out.println("add: "+result);
25         
26         context.setStrategy(new DivStrategy());
27         
28         result = context.getResult(9, 3);
29         
30         System.out.println("div: "+result);
31         
32         context.setStrategy(new MultiplyStrategy());
33         
34         result = context.getResult(9, 3);
35         
36         System.out.println("mul: "+result);
37     }
38 }

输出结果：

上面只是用到策略模式，下面加上简单工厂模式

工厂类

 1 package strategy;
 2 /**
 3  * 
 4  * @author CIACs
 5  *    Factory
 6  */
 7 public class Factory {
 8     public Strategy createStrategy(String str)
 9     {
10         if("AddStrategy".equalsIgnoreCase(str))
11         {
12             return new AddStrategy();
13         }
14         else
15             if("SubStrategy".equalsIgnoreCase(str))
16             {
 17                  リターン 新しいSubStrategy（）。
18              }
 19              他
20                  であれば（ "DivStrategy" .equalsIgnoreCase（STR））
 21                  {
 22                      リターン 新しいDivStrategy（）。
23                  }
 24                  他
25                      であれば（ "MultiplyStrategy" .equalsIgnoreCase（STR））
 26                      {
 27                          リターン 新しいMultiplyStrategy（）。
28                      }
 29                      、他の
30                          のリターン はnull ;
31      }
 32  
33 }

Clientクラス

1つの パッケージ戦略。
2  / ** 
3  * 
 4  * @author CIACs
 5  *クライアント
 6   * / 
7  パブリック クラスクライアント{
 8      パブリック 静的 ボイドメイン（文字列[]引数）{
 9       
10          コンテキストコンテキスト= 新しいコンテキスト（）。
11          int型の結果。
12          戦略戦略。
13          工場FAC = 新しい工場（）。
14          戦略= fac.createStrategy（ "AddStrategy" ）。
15          context.setStrategy（戦略）。
16              結果= context.getResult（9、3 ）;
17          のSystem.out.println（結果）。
18      }
 19 }

出力：

もちろん、もし、そうでなければ、本明細書で使用するファクトリクラスは、別のクライアントの戦略を生成するための良い、シンプルなファクトリパターンではありません。

要約：

　　戦略モードは、コード再利用の行を反映し、弱いリンクは、新しいコンポーネントの開発のための基礎を築く、それは強力なスケーラビリティを有し、コンポーネント間の接続が弱い、開発者は、多くの代替的なアセンブリを開発することを可能にしますそして維持しやすいです。戦略モードアルゴリズムのパッケージです、それは責任とアルゴリズムアルゴリズム自体で分割され、他のオブジェクト管理に委譲します。クライアントを使用する必要がありますどのような戦略を決定するので、クライアントは、クライアントの使用の難しさを増加させる、特定のポリシークラスのすべての違いを理解する必要があります。

ます。https：//www.cnblogs.com/Renyi-Fan/p/11027028.htmlで再現