groovy 闭包【命令模式】

在Java编程世界，有两个设计模式又简单、又经常使用，并且实现方式也很类似，这就是命令模式和策略模式。

有关这两个模式的讲解，在网络上真是汗牛充栋，你们能够随便搜索一下，就是一大堆。

能够简单的说，命令模式就是对行为或者命令的封装，而策略模式则是对算法的封装。对于行为或是说命令，还有算法，在编码的实现上都是要用到方法来实现的。

因此，咱们能够简单的把这两种模式这样理解：它们都是要对方法进行操做，像使用类和对象那样操做，好比传递和循环，而在Java等面向对象的编程语言中，方法是不能独立操做的，它必须依附于一个类和对象，而不能直接操做一个方法。基于这样的缘由，咱们设计了命令模式和策略模式来解决上面的问题。具体的实现就是抽象出一个接口来操做这些方法，而接口的实现就是用来具体实现一个个的行为或策略；而咱们就是经过引用接口来达到引用这些方法的目的。

下面举一个简单的例子来讲明上面的理解。好比，咱们要控制一盏灯的开关，利用命令模式能够设计以下。

咱们先抽象出一个接口来：

 

public interface Light {

   

    public void common();

 

}

 

这个接口是咱们可以引用开关动做的基础，下面咱们来实现灯的开关动做：

 

public class LightOn implements Light {

 

    public void common() {

       System.out.println("light turn on...");

    }

 

}

 

上面是开灯的动做，咱们接着写关灯的动做：

 

public class LightOff implements Light {

 

    public void common() {

       System.out.println("light turn off...");

    }

 

}

 

 

接着就是对上面的抽象的使用：

 

public class LightAction {

 

    public static void main(String[] args) {

      

       Light[] actions= new Light[]{new LightOn(),new LightOff(),new LightOn(),newLightOff()};

      

       for(int i=0;i<actions.length;i++)

       {

           actions[i].common();

       }

 

    }

 

}

 

运行结果为：

 

light turn on...

light turn off...

light turn on...

light turn off...

 

经过上面的例子，能够看到，所谓命令模式，就是咱们但愿将形如开灯和关灯这样的动做进行组合或者传递，而开灯和关灯在代码中对应为方法，在面向对象的编程中，方法是不能直接进行组合或传递的，因此咱们把开灯和关灯的方法依附于两个类“LightOn”和“LightOff”上。同时，为了方便方法之间的组合执行和传递，它们必须实现相同的接口，只有这样，“actions[i].common()”这样的语句才能正确执行。

经过了上面的分析，咱们能够得出结论：在Java语言中使用命令模式和策略模式，彻底是因为面向对象的语言中不能独立存在方法而致使的，同时方法也不能直接被传递，而必须依赖于类。

明白了上面的道理，咱们就能够想到，若是一个语言中的方法能够直接被看成对象来使用和传递，咱们就能够抛开命令模式和策略模式，而直接使用方法来操做。这就比命令模式和策略模式来得更为直接和简单易懂。

而咱们的Groovy语言正是存在这样的特色，咱们都知道，虽然在Groovy语言中，方法也不能直接被用来传递和使用，可是有一种方法的变形能够直接被看成对象来使用，这就是闭包。

下面，咱们来看看闭包是如何实现策略模式的。首先，咱们设计一个类来实现全部的方法：

class Light {

   

    def turnOn()

    {

       println 'light turn on...'

    }

   

    def turnOff()

    {

       println 'light turn off...'

    }

 

}

 

 

而后，咱们就能够实现命令模式了：

 

      def light = new Light()

     

      def lightOn = light.&turnOn

     

      def lightOff = light.&turnOff

     

      def commons = [lightOn,lightOff,lightOn,lightOff]

     

      commons.each{

         it.call()

  }

 

运行结果为：

 

light turn on...

light turn off...

light turn on...

light turn off...

 

能够看到，上面的代码比起Java语言中的命令模式实现起来要简单得多，但功能倒是同样的。

还有，模式的一个重要功能是它良好的扩展性。上面的命令模式就拥有良好的扩展性，好比咱们但愿增长一个方法来调节灯的亮度，使得更亮一些。命令模式在新增一个方法的时候，不会去修改已经写好的类，这样会致使已经写好的代码须要从新测试。咱们只需增长一个新的类：

 

public class Lighter implements Light {

 

    public void common() {

      

       System.out.println("make it lighter...");

      

    }

 

}

 

 

增长了新的类之后，咱们固然就能够照常使用它了：

 

 

       Light[] actions= new Light[]{new LightOn(),new Lighter(),new LightOff()};

      

       for(int i=0;i<actions.length;i++)

       {

           actions[i].common();

       }

   

 

运行结果为：

 

light turn on...

make it lighter...

light turn off...

 

那么，咱们在Groovy语言中使用闭包来实现的命令模式是否也拥有良好的扩展性呢？咱们的回答是：固然，它也有良好的扩展性。下面咱们来看闭包的命令模式的扩展性的例子。

首先，咱们能够新增一个类来实现这个新的行为：

 

class Lighter {

   

    def turnLighter()

    {

       println 'make it lighter...'

    }

 

}

 

这是一个新的类，固然没有修改到原来的类“Light”。下面，咱们来看怎么使用它：

 

     

       def light = new Light()

     

      def lightOn = light.&turnOn

     

      def lightOff = light.&turnOff

     

      def l = new Lighter()

      

       def lighter = l.&turnLighter

     

      def commons = [lightOn,lighter,lightOff]

     

      commons.each{

         it.call()

      }

   

 

 

运行结果为：

 

light turn on...

make it lighter...

light turn off...

 

咱们能够看到，在Groovy语言中，使用闭包实现的命令模式扩展起来也是同样的方便，它甚至能够更方便，咱们能够不用新增类，即“Lighter”都不须要。请看下面的编码：

     

       def light = new Light1()

     

      def lightOn = light.&turnOn

     

      def lightOff = light.&turnOff

 

       def lighter = {

           println 'make it lighter...'

       }

     

      def commons = [lightOn,lighter,lightOff]

     

      commons.each{

         it.call()

      }

   

 

运行结果为：

 

light turn on...

make it lighter...

light turn off...

 

 

在上面的编码中，咱们没有新增任何的类，却也实现了对灯的动做的扩展，这就是使用闭包的方便之处。

 

固然，咱们上面的例子都是以命令模式来说解的，其实策略模式也是同样的道理，只不过命令模式是对行为或动做的封装，而策略模式是对算法的封装，有兴趣的你，不妨使用闭包来实现策略模式看看。