Groovy04_闭包

1人阅读 评论(0) 收藏 举报
分类:

1. 闭包的基本定义和调用

ls4_0.groovy



// 1. 闭包
def closure = {
    println 'grovvy'
}
println closure.getClass()      // class lsn4_0$_run_closure1
// 2. 调用闭包
closure.call()      // grovvy
closure()           // grovvy

// 3. 闭包默认能够接收一个参数
def closure1 = {
    println it
}
closure1('hello,closure')       // hello,closure

// 4. 给一个闭包指定一个参数列表
def closure2={
    //->      //  -> 前面不加东西  表示 不接收参数
    i='Grovvy',j ->
    println i + j
}
closure2('hello,closure','Zeking')  // hello,closureZeking
closure2('Zeking')                      // GrovvyZeking

// 5. 闭包的参数绑定(柯里化闭包)
def closure3={
    i,j->
        println i+ " "+j
}
def curriedClosurse = closure3.ncurry(1,'2')  //从左至右  closure3.rcurry()这个是从右到左

curriedClosurse('java')     // java 2

// 6. 方法调用闭包

def clouser4={
    i,j->
        println i + "-" + j
}
def func(clouser4){
    clouser4()
}

interface  Action1{
    void call()
}

func(){

}

func (new Action1(){

    @Override
    void call() {
        println 'call'      // call
    }
})
// 在一个对象上调用() ,表示调用这个对象上的call方法
class Action2{
    def call(){
        println 'call2'
    }
}

new Action2()()     // call2  等于 new Action2().call()

2. this owner delegate

ls4_1.groovy

// Groovy的 元件

def closure = {
    int i->
}

// 1. 获取闭包的参数列表
println closure.parameterTypes              // [int]  参数类型
println closure.maximumNumberOfParameters   // 1

// 2. this owner delegate
def closure2 = {
    println "this is" +this             // this is      ls4_1@1184ab05
    println "owner is"+ owner           // owner is     ls4_1@1184ab05
    println "delegate is"+ delegate     // delegate is  ls4_1@1184ab05
                // 在这种情况下是一样的
}
closure2()

class TestClosure{
    def closure2 = {
        println "this is " +this             // this is     TestClosure@22a637e7
        println "owner is "+ owner           // owner is    TestClosure@22a637e7
        println "delegate is "+ delegate     // delegate is TestClosure@22a637e7

    }
}
new TestClosure().closure2()

class TestClosure2{
    // static 他就不是一个TestClosure2的实例对象了,而是TestClosure2这个类的对象(TestClosure2.class)
    // 这时候这3个任然一样
    def static closure2 = {
        println "this is " +this             // this is     TestClosure2
        println "owner is "+ owner           // owner is    TestClosure2
        println "delegate is "+ delegate     // delegate is TestClosure2

    }
}
TestClosure2.closure2()

class TestClosure3{
    def closure1 = {
        def closure2 = {
            println "this is " +this             // this is     TestClosure3@6e4784bc
            println "owner is "+ owner           // owner is    TestClosure3$_closure1@34b7ac2f
            println "delegate is "+ delegate     // delegate is TestClosure3$_closure1@34b7ac2f
        }
        closure2()
    }
}
new TestClosure3().closure1()
// 闭包中的 this 指的是定义它的时候 所在的类的this,静态闭包当中为class
// owner 定义它的时候 所在类的对象
// delegate 默认就是owner
// owner(拥有者)没法改变,但是我们可以修改delegate(代理)

def func(){
    println "func"
}

def closure3 = {
    func()
}

closure3()          // func

class TestFun{
    def func2(){
        println 'TestFun  func'
    }
}

def closure4 = {
    func2()     //  报错,不能直接调用func2  因为不在同一个类里面

}
closure4.delegate = new TestFun()  // 所以我们就可以通过改变这个闭包的代理的方式,来让他能够调用 fun2
closure4()                     // TestFun  func


class TestFun5{
    def fun5(){
        println 'TestFun5 :  fun5'
    }
}

def fun5(){
    println "ls4_1 : fun5"
}

def closure5 = {
    def func5 = {
        println "closure5 : fun5"
    }
    fun5()
}
closure5.delegate = new TestFun5()
//closure5.resolveStrategy = Closure.DELEGATE_FIRST  // 默认是  Closure.OWNER_FIRST  --》ls4_1 : fun5
                                                   //  Closure.DELEGATE_FIRST  -》TestFun5 :  fun5
                                                    // OWNER_ONLY 只在OWNER找
                                                    // DELEGATE_ONLY 只在代理找
                                                    // TO_SELF 只在自身找 就是在 closure5 闭包内部找(最没有意义的) --> closure5 : fun5
closure5()      // ls4_1 : fun5  为什么调用的是 ls4_1 : fun5?
                // 因为闭包有一个,代理策略
查看评论

php 连接库闭包 php 连接库闭包

  • 2011年08月11日 16:19
  • 1003B
  • 下载

尚硅谷——JavaScript闭包

  • 2018年01月31日 10:56
  • 423KB
  • 下载

关系运算有关的程序

  • 2015年11月29日 16:08
  • 2KB
  • 下载

闭包(Java中的闭包)

闭包Java中的闭包 What 简单理解 WHY HOW Java中的闭包 内部类 局部内部类 匿名内部类 闭包(Java中的闭包):What 闭包是指可以包含自由(未绑定到特定对象)变量的代码块;这...
  • yztbydh
  • yztbydh
  • 2017-07-28 17:20:47
  • 2284

什么是闭包,闭包的作用与好处是什么,何时使用闭包,对闭包的改进

闭包:外部函数定义的内部函数就是闭包。 闭包的作用及好处:闭包给访问外部函数定义的内部变量创造了条件。也将关于函数的一切封闭到了函数内部,减少了全局变量,这也是闭包的真实含义。 与普通函数...
  • wzw_mzm
  • wzw_mzm
  • 2017-02-24 14:11:23
  • 2903

闭包经典面试题

闭包应该是前段面试中经常碰到的面试题,很多人都会在这个问题上被问住。如果想要弄清楚就要掌握闭包的概念; 首先看面试题: for (var i = 1; i   setTimeout...
  • donggx
  • donggx
  • 2017-04-14 14:13:28
  • 8599

到底什么是闭包

感觉楼里大部分回答太复杂了,过于理论化,文绉绉地绕来绕去,没抓住本质和精髓。抄书谁不会啊?其实闭包没那么复杂。 最简洁、直击要害的回答,我能想到的分别有这么三句(版权属于 @张恂老师 ): 1、...
  • wy_Blog
  • wy_Blog
  • 2017-02-25 22:13:49
  • 2445

JavaScript闭包的原理与缺陷

闭包的原理闭包是指有权访问另一个函数作用域中的变量的函数。根据下面的代码示例来理解什么是闭包,在add函数内部的匿名函数中,访问到外部函数的变量outerArg,在执行add(10)之后外部函数返回了...
  • hongchh
  • hongchh
  • 2016-08-16 16:37:51
  • 1593

golang闭包里的坑

介绍 go的闭包是一个很有用的东西。但是如果你不了解闭包是如何工作的,那么他也会给你带来一堆的bug。这里我会拿出Go In Action这本书的一部分代码,来说一说在使用闭包的时候可能遇到的坑。全部...
  • future_challenger
  • future_challenger
  • 2015-08-30 16:56:06
  • 1690
    个人资料
    持之以恒
    等级:
    访问量: 2万+
    积分: 609
    排名: 8万+
    最新评论