策略模式,得实例理解,浅谈模版模式

  阅读了关于策略模式得文章,越来越发现一个好得设计模式得重要,因开发需要,了解了策略模式,特此与大家分享,文章代码来源于网络,谢谢.

 

 策略模式严格得解释是:

 

    定义一系列的算法，把他们一个个封装起来，并且使它们可相互替换。(即使用一个接口,从中有各种得实现方法)这样可使算法独立于使用它的客户而变化。

    策略模式以下列几条原则为基础：

一.每个对象都是一个具有职责的个体。

二.这些职责不同的具体实现是通过多态(通过接口)的使用来完成的。

三.相同的算法(可联系为接口)具有多个不同的实现(implements)，需要进行管理。

 

 

策略模式从通用理解得解释是:

 

 

策略是把不变的部分设计成父类，变化的部分设计成接口。子类继承了父类的所有特性，又实现接口部分的变化的方法。

比如每种鸭都会游泳，而且都是相同方式来游的，但不同的鸭子又会有不同的叫法。要具体化一种鸭子，这里有几个可以解决的方法，现在比较如下，就可以看出采用策略模式的好处了。

 

 

 

       方法一：由于鸭子的游泳方式一样，所以可以独立出来做为父类：

class Duck{

    public void swim(){

        System.out.println("duck swimming");

    }

}

       然后为不同的鸭子定义不同类，同时继承Duck类，有自已的叫法：

              class  WildDuck extends Duck{

    public void bark() {

       System.out.println("wild duck bark");

    }

}

这种方法是比较简单的实现，但是当一个类很大的时候，往往很多人来实现，这样有些方法会被落掉，而且当WildDuck要求有些变动后，要修改整个WildDuck类，有些伤筋动骨，用户要采用自已定义的WildDuck类时，更换也不方便。对于要求松偶合时，通过接口来调用灵活得很多。

       方法二：用abstract类来实现，把相同的行为写定，不同的行为设计成abstract方法，由子类来实现。

abstract class Duck{

    public void swim(){

       System.out.println("duck swimming");

    }

   

    public abstract void bark();

}

 

class WildDuck extends Duck{

    public void bark() {

       System.out.println("wild duck bark");    

    }

}

如果各种鸭子都有这种行为，那这也是一种很好的实现方法，但问题是，有些鸭子具备这个行为，但另外一种又不具备这种行为，比如有些鸭子会孵蛋，有些鸭子不会孵蛋。那总不能给不孵蛋的鸭子有孵蛋的行为吧？

 

 

       方法三：采用策略模式，相同的行为在父类中实现，然后各种类型的鸭子有各自独立的接口。

              class Duck{

    public void swim(){

       System.out.println("duck swimming");

    }

}

 

interface WildDuck{

    public void swim();

    public void bark();

}

 

interface HatchDuck{

    public void swim();

    public void bark();

    public void hatch();

}

 

class WildDuckImp extends Duck implements WildDuck{

    public void bark() {

       System.out.println("wild duck bark");    

    }

}

 

class HatchDuckImp extends Duck implements HatchDuck{

    public void bark() {

       System.out.println("hatch duck bark");

    }

    public void hatch() {

       System.out.println("hatch duck hatching");

    }

}

       采用策略模式以后，用户可以自行更换自定义的实现类，也不会出现行为“混乱”这种局面。

 

 

 

 

 

还有这个例子:

 

 

interface DatabaseStrategy{

        public void process();

    }

 

 

class MysqlDBStrategy implements DatabaseStrategy{

    public void process() {

       System.out.println("处理Mysql数据库连接");

    }

}

 

class OracleDBStrategy implements DatabaseStrategy{

    public void process() {

       System.out.println("处理Oracle数据库连接");

    }

}

 

class DataBaseManager{

    public void process(DatabaseStrategy dbStrategy){

       dbStrategy.process();

    }

}

 

publicclass StrategyClient {

    public static void main(String[] args) {

       MysqlDBStrategy mysql=new MysqlDBStrategy();

       DataBaseManager manager=new DataBaseManager();

       manager.process(mysql);

       OracleDBStrategy oracle=new OracleDBStrategy();

       manager.process(oracle);

    }

}