Groovy探索之Decorate模式

最新推荐文章于 2024-04-21 17:15:12 发布
最新推荐文章于 2024-04-21 17:15:12 发布
阅读量3.4k 收藏 3
点赞数
分类专栏： Groovy/Grails 文章标签： groovy 语言 java class float 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hivon/article/details/2485072
版权
                                    Groovy探索之Decorate模式
 
 
Decorate模式是Java编程中比较常用的一种模式，有关Decorate模式的基本知识，如概念、使用场合以及如何使用，请大家查看相关文档。本文所要关注如何在Groovy语言中实现Decorate模式，以及这种实现与Java语言实现的区别，使得我们更加深入的理解Groovy语言的动态性，同时学会在Groovy语言中使用Decorate模式。
说到Decorate模式，一个最最常用的例子是咖啡的例子。下面我们来看看在Java语言中怎么实现这个例子的。
首先是一个接口，接口是Java语言面向对象的基础：
public interface Coffee {
   
        public void descript();
 
}
 
为了例子的简单性，我让Coffee接口只有一个方法。然后，我们要实现原咖啡类：
public class OriginCoffee implements Coffee {
 
        public void descript() {
           System. out .print( "Coffee" );
 
        }
}
 
接着，我们来实现加冰的咖啡：
public class IceCoffee implements Coffee {
   
        private Coffee coffee ;
        public IceCoffee(Coffee coffee)
        {
           this . coffee = coffee;
        }
        public void descript() {
           this . coffee .descript();
           System. out .print( ",with ice" );
 
        }
}
 
看到了上面的两个类 OriginCoffee 和 IceCoffee ，可以看出在 Java 语言中实现 Decorate 模式的一般方法，在此我们就不多说了。
下面是加奶咖啡的实现：
public class MilkCoffee implements Coffee {
 
        private Coffee coffee ;
   
        public MilkCoffee(Coffee coffee)
        {
           this . coffee = coffee;
        }
 
        public void descript() {
           this . coffee .descript();
           System. out .print( ",with Milk" );
        }
}
 
下面，我们来看看 Decorate 模式的客户端实现，首先我们要加奶咖啡：
       Coffee coffee = new MilkCoffee( new OriginCoffee());
    coffee.descript();
 
运行结果为：
Coffee,with Milk
 
如果我们要加奶又加冰的咖啡：
Coffee coffee = new MilkCoffee( new IceCoffee( new OriginCoffee()));
    coffee.descript();
 
运行结果为 :
Coffee,with ice,with Milk
 
在上面的例子中，我们用 Java 实现了一个 Decorate 模式，那么同样的例子在 Groovy 语言又是怎么实现的呢？
我们知道，基于 Groovy 语言的动态性，在很多时候都可以省略接口，在实现 Decorate 模式的时候也一样。
首先来看我们的原咖啡的实现：
class OriginCoffee {
   public descript()
  {
          print 'Coffee'
  }
}
 
没有接口，只有一个方法，很简单。下面是冰咖啡的实现：
class IceCoffee {
    private delegate;
    public IceCoffee(delegate)
    {
       this .delegate = delegate
    }
 
      public descript()
     {
         this .delegate.descript()
         print ',with Ice'
     }
 
}
 
也很简单，基于 Groovy 语言的动态性，我们可以直接编写形如“ this .delegate.descript() ”这样的代码，而在 Java 语言中，我们必须借助接口来实现。
同理来实现加奶咖啡：
class MilkCoffee {
 
    private delegate;
   
    public MilkCoffee(delegate)
    {
       this .delegate = delegate
    }
 
      public descript()
     {
         this .delegate.descript()
         print ',with Milk'
     }
 
}
 
客户端的使用和 Java 语言一样：
      def coffee = new MilkCoffee( new IceCoffee( new OriginCoffee()))
     
 coffee.descript()
 
运行结果为：
Coffee,with Ice,with Milk
 
上面，我们就使用Groovy语言实现了一个最简单的Decorate模式，一切都很简单，也很好理解。如果我们的咖啡复杂一点，比如还要实现计算价格的功能，比如下面的原咖啡：
class OriginCoffee {
   
    float payMount
   
    public pay()
    {
       this .payMount = 2
       return payMount
    }
   
    public printPay()
    {
       println "Total pay mount: ${this.payMount}"
    }
 
      public descript()
     {
         print 'Coffee'
     }
 
}
 
这个类有三个方法：“ descript ”用来描述咖啡种类；“ pay ”用来计算价格；“ printPay ”用来打印咖啡的价格。那么我们该怎么实现加冰的咖啡呢？
当然，我们依然可以沿用上面的方法，其实现如下：
class IceCoffee {
 
    float payMount
   
    private delegate;
   
    public IceCoffee(delegate)
    {
       this .delegate = delegate
    }
   
    public pay()
    {
       this .payMount = this .delegate.pay()+ 0 . 5
       return this .payMount
    }
   
    public printPay()
    {
       println this .payMount
    }
 
      public descript()
     {
         this .delegate.descript()
           print ',with Ice'
     }
}
 
这次实现 Decorate 模式的一般实现模式。我曾经说过，设计模式通过解耦来取得的代码的扩展性，同时也带来了编码的繁琐性。如上面的 IceCoffee 类，需要同时实现三个方法，随着代码的扩展，后面的 MilkCoffee 类、 SugarCoffee 类，都需要同时实现以上的三个方法，十分的繁琐。
在 Groovy 语言中，结合 MOP 编程，我们还可以对上面的繁琐代码进行进一步的简化，请看下面的 IceCoffee 类：
class IceCoffee {
 
    float payMount
   
    private delegate;
   
    public IceCoffee(delegate)
    {
       this .delegate = delegate
    }
   
    def invokeMethod(String name,args)
    {
       if (name == 'pay' )
       {
           this .payMount = this .delegate.pay()+ 0 . 5
           return this .payMount
       }
       else if (name == 'descript' )
       {
           this .delegate.descript()
           print ',with Ice'
       }
       else
       {
           println this .payMount
       }
    }
 
}
 
不错，又是“ invokeMethod ”方法，让我们在一个方法里把三个功能一起实现，达到简化编码的目的。下面是加奶的咖啡实现：
class MilkCoffee {
    float payMount
    private delegate;
    public MilkCoffee(delegate)
    {
       this .delegate = delegate
    }
   
    def invokeMethod(String name,args)
    {
       if (name == 'pay' )
       {
           this .payMount = this .delegate.pay()+ 1
           return this .payMount
       }
       else if (name == 'descript' )
       {
           this .delegate.descript()
           print ',with Milk'
       }
       else
       {
           println this .payMount
       }
    }
}
 
最后，我们来看看客户端：
      def coffee = new MilkCoffee( new IceCoffee( new OriginCoffee()))
     coffee.descript()
      println ''
     coffee.pay()
 coffee.printPay()
 
打印结果为：
Coffee,with Ice,with Milk
3.5
 
 
hivon
关注
专栏目录
Groovy(第九节) Groovy 之单元测试
孙叫兽的博客
02-27 593
利用 JavaSong利用 Java。
Java调用Groovy，实时动态加载数据库groovy脚本
06-08
1. 引入Groovy库：在Java项目中添加Groovy的相关依赖，通常是`groovy-all`，确保Java能够访问Groovy运行时环境。 2. 创建GroovyClassLoader：使用这个类加载器可以动态加载和执行Groovy脚本。它继承自Java的...
设计模式--装饰模式Decorate（结构型）
weixin_30243533的博客
12-30 171
一、装饰模式 动态地给一个对象添加额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活。有时我们希望给某个对象而不是整个类添加一些功能。 二、UML图 1.Component(概念中提到的对象接口)，也就是“被装饰者”。2.ConcreateComponent(未添加任何职责的，对象接口的子类)。3.Decorator(装饰者抽象类)，扩张了对象接口的功能。4.ConcreteDrc...
Decorate 模式
test
05-28 1119
作用：装饰器模式有助于将其他行为或责任动态附加到对象，装饰器为扩展功能提供了子类化的灵活替代方案。这也被称为包装。如果您的应用程序进行某种过滤，那么装饰器可能是考虑这项工作的良好模式。#include <iostream> #include <string> using namespace std; class Car { protected: string _s...
Decorate(修饰模式)
qq_19372831的博客
05-09 3229
前言: 当希望动态地为一个对象(有时候我们想给某个对象添加一些职责, 而不是整个类)填写一些额外的职责时, 修饰模式比生成子类更加的灵活示例: 以一个CTextView为例, 我们现在有一个文本视图类, 该类提供一个基本的文本编辑框, 当我们渴望拥有一个带滚动条的文本视图时, 我们也许会从CTextView类中派生出一个CScrollTextVIew, 而当我们想要一个带边框的文本视图时, 我们
装饰模式（Decorator）
行走
05-02 451
设计模式系列 Decorator装饰模式——对象结构模式 1.意图 动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活 2.适用性 在不影响其他对象的情况下，以动态、透明的方法给单个对象添加职责 处理那些可以撤销的职责 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目...
设计模式 装饰模式（decorate）
时意
11-22 246
装饰器模式 装饰器模式 个人感觉也很常用 在项目中如果一个实体功能需要不断的丰富 就需要装饰器 比如一个奥迪系列的汽车 有A4 A1 A6 再买的时候 就喜欢选择很多配件 比如 GPS 倒车影像 等等 在不同的型号里 配置不同的装配 最后在生成总价 这种功能怎么办？ 要是我的话 第一反应就是 俩个抽象 一个是汽车 一个是配件 汽车抽象里面有一个集合 然后用方法来控制 配件的增...
深入探索Groovy脚本：文件操作的艺术
最新发布
10-04
Groovy，作为一种动态语言，以其简洁的语法和强大的功能在Java虚拟机（JVM）上运行，为文件操作提供了一个非常灵活和强大的工具。本文将深入探讨如何使用Groovy脚本进行文件操作，包括文件的创建、读取、写入、删除...
基于Groovy与Java融合的Groovy学习实践之路设计源码
09-25
该项目是一套基于Groovy与Java融合的Groovy学习实践之路源码设计，总计包含91个文件，其中Groovy文件71个，XML文件6个，Java文件4个，Markdown文件2个，JSON文件2个，TXT文件2个，Git忽略文件1个，IML文件1个，以及...
深入浅出设计模式(9)——Decorate模式
Secret Island
10-11 1521
1、一个原则   类应该对扩展开放，对修改关闭   2、定义装饰者模式 装饰者模式动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案。         1.      Component就是装饰器模式中公共方法的类，在装饰器模式结构图的顶层。 2.      ConcreateComponent是转换器模式中具体的被装饰的类，IO
C++23种设计模式（四）--Decorate（装饰模式）
fairy's husband的博客
03-15 358
1.装饰模式概述 1.1、意图 动态的给一个对象添加一些额外的职责。就增加功能来说，Decorate模式相比生成子类更为灵活。 1.2、适用性 在不影响其他对象的情况下，以动态，透明的方式给单个对象添加职责。 处理那些可以撤销的职责。 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况是因为类定义被隐藏...
Groovy 设计模式 -- 抽象工厂 模式
weixin_34116110的博客
03-27 154
  抽象工厂 https://blog.csdn.net/wyxhd2008/article/details/5597975 首先来看看这两者的定义区别： 工厂模式：定义一个用于创建对象的借口，让子类决定实例化哪一个类 抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类        个人觉得这个区别在于产品，如果产品单一，最合适用工厂模式，但是如果...
Groovy 设计模式 -- 适配器模式
weixin_34102807的博客
04-05 116
Adapter Pattern http://groovy-lang.org/design-patterns.html#_adapter_pattern 适配器模式，对象存在一个接口， 此接口在此对象中不能被另外一类对象使用， 提供对象的适配接口，将此接口做包装，适配为另外一类接口。 这类模式也叫包装模式（wrapper pattern） The Adapter Pattern (som...
【设计模式】7、decorate 装饰模式
呆呆的猫的博客
04-21 619
如果希望增强行为，可以使用 decorate 模式。且支持嵌套多层（套娃）
Groovy 设计模式 -- 享元模式
weixin_33828101的博客
04-05 83
Flyweight Pattern 享元模式， 将对象的相同属性， 以节省内存为目的，存储为一份公共对象， 所有对象共用此分对象。 The Flyweight Pattern is a pattern for greatly reducing memory requirements by not requiring that heavy-weight objects be create...
Groovy 设计模式 -- 组合模式
weixin_34032827的博客
04-05 130
Composite Pattern http://groovy-lang.org/design-patterns.html#_chain_of_responsibility_pattern 组合模式，允许你将多个对象作为一组对象对待。这些对象具有层次结构，并具有相同的 方法， 有叶子节点和组合节点。 组合节点，调用子节点（叶子和组合节点）的方法，实现组合节点自身的方法。   The ...
结构型模式之装饰者模式
渔夫的博客
07-22 233
1 装饰者模式定义 装饰模式（Decorator Pattern）指的是在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。 设计原则：多用组合，少用继承！对扩展开放，对修改关闭！ 利用继承设计子类的行为，是在编译时静态决定的，而且所有的子类都会继承到相同的行为。然而，如果能够利用组合的做法扩展对象的行为，就可以在运行时动态地进行扩展。 2 装饰者模式特点 通过继承的方式可以使子类具有父类的属性和方法。子类继承父类后，因为一些业务需求可以通过
Groovy 设计模式 -- 借贷
weixin_33950035的博客
04-05 83
借贷模式 http://groovy-lang.org/design-patterns.html#_loan_my_resource_pattern The Loan my Resource pattern ensures that a resource is deterministically disposed of once it goes out of scope. T...
Groovy设计模式探索：闭包与动态类型的威力
Groovy之旅的部分介绍了Groovy语言的基础知识，包括它的背景、与Java的兼容性、语言特性、运行环境、编译与执行方式、以及IDE和编辑器支持。Groovy以其简洁的语法、强大的代码能力和社区支持吸引着开发者。文章还...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值