Groovy笔记(五)之动态类型

动态类型

1. Groovy的动态特性:比如在一个订单系统中，可以使用一个Mock对象毫不费力的替换掉一个信用卡处理对象，以便进行快速的自动化测试。

       /**
        * man woman cat这些类没有扩展任何的公共类或者实现接口
        * 借助groovy的动态特性，我们能够在takeHelp方法中使用所有
        * 这些类.takeHelp方法接收一个helper但是没有指定类型，这样
        * 类型默认为Object。此外这里在它上面调用了doSomething方法
        * 这就是能力式设计
        */
       def class Dongtai {
           def takeHelp(helper) {
               //respondsTo 可以判断是否具备此方法
               if (helper.metaClass.respondsTo(helper, 'doSomething')) {
                   helper.doSomething()
               } else {
                   println(helper.getClass().getName())
               }
       
           }
       
           public static void main(String[] args) {
               /**
                * 输出
                * man doSomething
                * Woman doSomething
                * Cat doSomething
                * com.jannal.one.Pig
                */
               def dongdai = new Dongtai()
               dongdai.takeHelp(new Man())
               dongdai.takeHelp(new Woman())
               dongdai.takeHelp(new Cat())
               dongdai.takeHelp(new Pig())
           }
       }
       
       //男人
       def class Man {
           void doSomething() {
               println "man doSomething"
           }
       }
       //女人
       def class Woman {
           void doSomething() {
               println "Woman doSomething"
           }
       }
       //猫
       def class Cat {
           void doSomething() {
               println "Cat doSomething"
           }
       }
       //猪 没有doSomething
       def class Pig {
       
       }
   
   

2. 静态类型检查:对于使用@TypeChecked标记的代码，在编译时，编译器会验证方法或属性是否从属于该类。这会阻止我们使用任何元编程的能力。静态类型检查生效时，不能直接调用动态方法，但是可以使用invokeMethod()方法

       /**
        * 静态类型检查 @TypeChecked 用在类上或者方法上
        * 类：则类型检查会在该类中所有的方法、闭包和内部类上执行
        * 方法：仅仅在目标方法上
        */
       @TypeChecked
       class TypeCheckTest {
           public void aa(){}
       
           public void cc(Object instance){
               //不需要强制类型转换
               if( instance instanceof String){
                   print instance.length()
               }else{
                   print instance
               }
           }
           //通过参数去掉类型检查
           @TypeChecked(TypeCheckingMode.SKIP)
           public void dd(def obj){
               print obj.length()
           }
           public static void main(String[] args) {
               def test = new TypeCheckTest()
               test.aa()
               //test.bb()
           }
       }
   

3. 静态编译:@CompileStatic让Groovy执行静态编译。此时生成的字节码与javac生成的字节码很像。

闭包

1. 闭包: 闭包是函数式编程lambda表达式派生而来的的。一个Lambda表达式指定了一个函数的参数与映射。
   2.高阶函数：以函数为参数或返回一个函数作为结果的函数。

       class ClosureTest {
       
           def a(i, block) {
               print(i)
               block()
           }
       
           def b(i, block) {
               print(i)
               block(i)
           }
       
       
       
           public static void main(String[] args) {
       
               def test = new ClosureTest()
               //1
               test.a(1, { println "闭包代码块" })
               //2 如果闭包是最后一个参数，可以如下方式调用
               test.a(1) { println("闭包代码块") }
               //1闭包代码块1
               test.b(1) { num -> println "闭包代码块$num" }
               //如果只向闭包中传入一个参数可以使用it代替
               test.b(1) { println "闭包代码块$it" }
       
       
           }
       
       
       }