文档章节

Java设计模式之策略模式(个人学习整理用)

i源源的圆圆
 i源源的圆圆
发布于 2016/09/14 15:59
字数 2456
阅读 7
收藏 0

策略模式

1、策略的中文定义是:指策略、计谋。一般是指:

①. 可以实现目标的方案集合;

②. 根据形势发展而制定的行动方针和斗争方法;

③. 有斗争艺术,能注意方式方法

 

2、策略模式策略模式是处理算法的不同变体的一种行为模式,通过在抽象策略中定义算法接口或封装算法标识,实现该抽象策略的具体子类成为一个单独的算法,即具体策略。策略模式使用多个类来区别不同的行为,使用策略模式避免暴露复杂的、与算法相关的内部数据结构。当一个类中的操作以多个条件分支语句的形式出现的时候,可以使用策略模式将相关的条件分支移入各自的具体策略类中以代替这些条件语句,从而减少系统处理的复杂度。
3、介绍
(1)意图:定义一系列的算法,并把他们一个个封装起来,并且使他们可以相互替换;
(2)主要解决:在有多种算法相似的情况下,使用if….else所带来的的复杂和难以维护。
(3)何时使用:一个系统有许多许多类,而区分这些类的标准只是他们的直接行为;
(4)例子以及如何解决:

模拟鸭子游戏的应用程序,要求:游戏中会出现各种颜色外形的鸭子,一边游泳戏水,一边呱呱叫。

第一种方法:(一次性代码)
直接编写出各种鸭子的类:MallardDuck//野鸭,RedheadDuck//红头鸭,各类有三个方法:
quack():叫的方法
swim():游水的方法
display():外形的方法

第二种方法:运用继承的特性,将其中共同的部分提升出来,避免重复编程。
即:设计一个鸭子的超类(Superclass),并让各种鸭子继承这个超类。
public class Duck{
     public void quack(){  //呱呱叫
              System.out.println("呱呱叫");
      }
     public void swim(){   //游泳
            System.out.println(" 游泳");
      }    
     public  abstratact void display(); /*因为外观不一样,让子类自己去决定了。*/
}

对于它的子类只需简单的继承就可以了,并实现自己的display()方法。
//野鸭
 public class MallardDuck extends Duck{
     public void display(){
          System.out.println("野鸭的颜色...");
   }
 }
//红头鸭
 public class RedheadDuck extends Duck{
     public void display(){
          System.out.println("红头鸭的颜色...");
   }
}

不幸的是,现在客户又提出了新的需求,想让鸭子飞起来。这个对于我们OO程序员,在简单不过了,在超类中在加一

个方法就可以了。
public class Duck{
     public void quack(){  //呱呱叫
              System.out.println("呱呱叫");
      }
     public void swim(){   //游泳
            System.out.println(" 游泳");
    }    
    public  abstract void display(); /*因为外观不一样,让子类自己去决定了。*/
   public void fly(){
        System.out.println("飞吧!鸭子"); 
  }
}
对于不能飞的鸭子,在子类中只需简单的覆盖。
//残废鸭
 public class DisabledDuck extends Duck{
     public void display(){
          System.out.println("残废鸭的颜色...");
   }
   public void fly(){
    //覆盖,变成什么事都不做。 
  }

其它会飞的鸭子不用覆盖。

这样所有的继承这个超类的鸭子都会fly了。但是问题又出来了,客户又提出有的鸭子会飞,有的不能飞。

>>>>>>点评:
对于上面的设计,你可能发现一些弊端,如果超类有新的特性,子类都必须变动,这是我们开发最不喜欢看到的,一个类变让另一个类也跟着变,这有点不符合OO设计了。这样很显然的耦合了一起。利用继承-->耦合度太高了.

第三种方法:
用接口改进.

我们把容易引起变化的部分提取出来并封装之,来应付以后的变法。虽然代码量加大了,但可用性提高了,耦合度也降低了。

我们把Duck中的fly方法和quack提取出来。
    public interface Flyable{
      public void fly(); 
  }
   public interface Quackable{
     public void quack();
  }
  最后Duck的设计成为:
public class Duck{
     public void swim(){   //游泳
            System.out.println(" 游泳");
    }    
    public  abstract void display(); /*因为外观不一样,让子类自 己去决定了。*/
}
 而MallardDuck,RedheadDuck,DisabledDuck 就可以写成为:
//野鸭
 public class MallardDuck extends Duck  implements Flyable,Quackable{
     public void display(){
          System.out.println("野鸭的颜色...");
   }
   public void fly(){
    //实现该方法
  }
   public void quack(){
    //实现该方法
  }
 }
//红头鸭
 public class RedheadDuck extends Duck implements Flyable,Quackable{
     public void display(){
          System.out.println("红头鸭的颜色...");
   }
   public void fly(){
    //实现该方法
  }
   public void quack(){
    //实现该方法
  }

//残废鸭 只实现Quackable(能叫不能飞)
 public class DisabledDuck extends Duck implements Quackable{
     public void display(){
          System.out.println("残废鸭的颜色...");
   }
   public void quack(){
    //实现该方法
  }
}

>>>>>>点评:
好处:
这样已设计,我们的程序就降低了它们之间的耦合。
不足:
Flyable和 Quackable接口一开始似乎还挺不错的,解决了问题(只有会飞到鸭子才实现 Flyable),但是Java接口不具有实现代码,所以实现接口无法达到代码的复用。

第四种方法:

对上面各方式的总结:
继承的好处:让共同部分,可以复用.避免重复编程.

继承的不好:耦合性高.一旦超类添加一个新方法,子类都继承,拥有此方法,

                        若子类相当部分不实现此方法,则要进行大批量修改.

                         继承时,子类就不可继承其它类了.

接口的好处:解决了继承耦合性高的问题.

                         且可让实现类,继承或实现其它类或接口.

接口的不好:不能真正实现代码的复用.可用以下的策略模式来解决.

 

------------------------- strategy(策略模式) -------------------------
我们有一个设计原则:
找出应用中相同之处,且不容易发生变化的东西,把它们抽取到抽象类中,让子类去继承它们;
找出应用中可能需要变化之处,把它们独立出来,不要和那些不需要变化的代码混在一起。 -->important.

现在,为了要分开“变化和不变化的部分”,我们准备建立两组类(完全远离Duck类),一个是"fly"相关的,另一个

是“quack”相关的,每一组类将实现各自的动作。比方说,我们可能有一个类实现“呱呱叫”,另一个类实现“吱吱

叫”,还有一个类实现“安静”。

首先写两个接口。FlyBehavior(飞行行为)和QuackBehavior(叫的行为).
  public interface FlyBehavior{
     public void fly();     
 }
 public interface QuackBehavior{
     public void quack();
 }
 我们在定义一些针对FlyBehavior的具体实现。
 public class FlyWithWings implements FlyBehavior{
    public void  fly(){
     //实现了所有有翅膀的鸭子飞行行为。
   }
 }

public class FlyNoWay implements FlyBehavior{
 
    public void  fly(){
      //什么都不做,不会飞
    }
 }   
针对QuackBehavior的几种具体实现。
public class Quack implements QuackBehavior{
    public void quack(){
      //实现呱呱叫的鸭子
  }
}
 
public class Squeak implements QuackBehavior{
    public void quack(){
      //实现吱吱叫的鸭子 
  }
}
 
public class MuteQuack implements QuackBehavior{
    public void quack(){
      //什么都不做,不会叫
  }
}

点评一:
这样的设计,可以让飞行和呱呱叫的动作被其他的对象复用,因为这些行为已经与鸭子类无关了。而我们增加一些新

的行为,不会影响到既有的行为类,也不会影响“使用”到飞行行为的鸭子类。

最后我们看看Duck 如何设计。
     public class Duck{        --------->在抽象类中,声明各接口,定义各接口对应的方法.
      FlyBehavior flyBehavior;//接口
      QuackBehavior quackBehavior;//接口
       public Duck(){}
       public abstract void display();
       public void swim(){
        //实现游泳的行为
        }
       public void performFly(){
            flyBehavior.fly();  -->由于是接口,会根据继承类实现的方式,而调用相应的方法.
     }
     public void performQuack(){
          quackBehavior.quack();();
    }
 }

看看MallardDuck如何实现。
----->通过构造方法,生成'飞','叫'具体实现类的实例,从而指定'飞','叫'的具体属性
 public class MallardDuck extends Duck{
       public MallardDuck {       
        flyBehavior = new FlyWithWings ();
        quackBehavior = new Quack(); 
      //因为MallardDuck 继承了Duck,所有具有flyBehavior 与quackBehavior 实例变量}
    public void display(){
     //实现
   }
 }
 这样就满足了即可以飞,又可以叫,同时展现自己的颜色了。

这样的设计我们可以看到是把flyBehavior ,quackBehavior 的实例化写在子类了。我们还可以动态的来决定。
  我们只需在Duck中加上两个方法。

 

在构造方法中对属性进行赋值与用属性的setter的区别:

构造方法中对属性进行赋值:固定,不可变;

用属性的setter,可以在实例化对象后,动态的变化,比较灵活。

 


  public class Duck{
      FlyBehavior flyBehavior;//接口
      QuackBehavior quackBehavior;//接口
      public void setFlyBehavior(FlyBehavior flyBehavior){
            this.flyBehavior = flyBehavior;
     }
    public void setQuackBehavior(QuackBehavior quackBehavior  {
            this.quackBehavior= quackBehavior;
     }
 }

 
(5)关键代码:实现同一个接口
(6)扩展应用例子:
    1、诸葛亮的锦囊妙计,每一个锦囊就是一个策略。
    2、旅行的出游方式,选择骑自行车、坐汽车还是火车,每一种
         出行方式都是一个策略
(7)优缺点
①优点:算法可以自由切换;避免使用多重条件判断;扩展
              性良好。
②缺点:策略类会增多;所有策略类都需要对外暴露接口
(8)使用场景:
         ①如果一个系统里面有许多类,而他们之间的区别仅在于它
               们的行为,那么使用策略模式可以动态地让一个对象在许、
            多行为中选择一种行为;
         ②一个系统需要动态地在几种算法中选择一种;
         ③如果一个对象有很多的行为,如果不给适当的模式,这些行为就只好使用多重判断的条件选择语句来实现;
注意事项:如果一个系统的策略多于四个,就要考虑使用混合模式,解决策略类膨胀的问题。
(菜鸟程序员的整理,还望大神看到有错的地方能指点指点。谢谢,么么哒(*  ̄3)(ε ̄ *))

 

© 著作权归作者所有

共有 人打赏支持
i源源的圆圆
粉丝 1
博文 1
码字总数 2456
作品 0
广州
私信 提问
设计模式15——Template Method设计模式

Template Method模板方法设计模式定义一个操作中算法的骨架,将具体步骤的执行延迟到子类中实现。Java中的抽象类就是使用了模板方法设计模式。模板方法设计模式结构如下: 以文档处理为例,T...

小米米儿小
2014/01/24
0
0
设计模式 2014-12-19

book: 阎宏《JAVA与模式》 架构设计栏目 http://blog.csdn.net/enterprise/column.html 概要: http://bbs.csdn.net/forums/Embeddeddriver 23种设计模式分别是: 1.单例模式 2.工厂方法模式...

jayronwang
2014/12/19
0
0
学了那么多年设计模式依然不会用!那可真蠢!

什么是设计模式? 设计模式(Design Pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决...

GitChat技术杂谈
2018/10/26
0
0
Java单例设计模式的理解与常规实现方式

1:Java中单例模式是一种常见的设计模式,单例模式有以下特点:   单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例。 2:java中单例模式的写法也有很多种,我在这...

动力节点
01/02
0
0
关于spring是用注解好,还是用xml好?

最近学习了一下java的工厂设计模式,感觉工厂模式最大的优点和spring的IOC有些相像,比如我们为一个User接口写了多个实现,记为:UserImpl1、UserImpl2,可以很轻松的来回切换实现,对于工厂...

上帝爱众生
2015/05/19
435
6

没有更多内容

加载失败,请刷新页面

加载更多

dockerfile 镜像构建(1)

通用dockerfile 利用已经编译好的.jar 来构建镜像。要构建的目录如下: [root@iZuf61quxhnlk9m2tkx16cZ demo_jar]# docker build -t demo:1 . 运行镜像: [root@iZuf61quxhnlk9m2tkx16cZ de...

Canaan_
22分钟前
0
0
Redis radix tree源码解析

Redis实现了不定长压缩前缀的radix tree,用在集群模式下存储slot对应的的所有key信息。本文将详述在Redis中如何实现radix tree。 核心数据结构 raxNode是radix tree的核心数据结构,其结构体...

阿里云云栖社区
25分钟前
5
0
vue import 传入变量

在做动态添加component的时候,传入变量就会报错,出现以下错误信息: vue-router.esm.js?fe87:1921 Error: Cannot find module '@/components/index'. at eval (eval at ./src/components ......

朝如青丝暮成雪
27分钟前
0
0
Flutter开发 Dio拦截器实现token验证过期的功能

前言: 之前分享过在Android中使用Retrofit实现token失效刷新的处理方案,现在Flutter项目也有“token验证过期”的需求,所以接下来我简单总结一下在Flutter项目中如何实现自动刷新token并重...

EmilyWu
28分钟前
6
0
final Map可以修改内容,final 常量不能修改

1.final Map 可以put元素,但是不可以重新赋值 如: final Map map = new HashMap(); map = new HashMap();//不可以 因为栈中变量map引用地址不能修改 2.final str = “aa”; str = "bb";/......

qimh
31分钟前
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部