/**
     * 从给定的索引处开始绑定闭包参数
     *
     * @param argument 要绑定参数的闭包
     * @return the 绑定参数后新创建的闭包
     * @see #ncurry(int, Object...)
     */
    public Closure<V> ncurry(int n, final Object argument) {
        return ncurry(n, new Object[]{argument});
    }

// 定义闭包变量 , 声明两个参数 a, b
        // 并为闭包指定默认值
        def closure5 = { a = 0, b = "Groovy" ->
            println "${a} : ${b}"
        }
        // 闭包有默认值 , 调用时可以不传入参数
        closure5()
        // 从第 n 个参数开始绑定闭包参数 ,
        // 注意调用了 curry / ncurry / rcurry 方法后 , 之前的默认值就覆盖了
        // 此时第一个参数没有值了
        // 调用时 , 必须传入第一个参数只才可以
        def closure8 =closure5.ncurry(1, "Kotlin")
        // 闭包的第一个默认值被取消 , 此时必须传入第一个参数的值才能执行该闭包
        // 否则报错
        closure8(3)

0 : Groovy
3 : Kotlin

import org.codehaus.groovy.ant.Groovy
class Test {
    static void main(args) {
        // I. 接收默认一个参数的变薄
        // 定义闭包变量
        def closure = {
            println "Accept One Arguments : ${it}"
        }
        // 调用闭包
        closure.call("Hello");
        closure("Hello");
        // II. 不接收任何参数的闭包
        // 定义闭包变量 , 不允许传入参数
        def closure2 = { ->
            println "Not Accept Arguments"
        }
        // 传入参数会报错
        //closure2("Hello")
        // 调用闭包 , 不能传入参数
        closure2.call();
        closure2();
        // III. 接收一个自定义参数的闭包
        // 定义闭包变量 , 声明一个参数 a
        def closure3 = { a ->
            println "${a}"
        }
        // 调用闭包 , 不能传入参数
        closure3.call(1);
        closure3(2);
        // IV. 接收两个自定义参数的闭包
        // 定义闭包变量 , 声明两个参数 a, b
        // 在闭包中打印这两个参数
        def closure4 = { a, b ->
            println "${a} : ${b}"
        }
        // 调用闭包 , 不能传入参数
        closure4.call(1, 2);
        closure4(3, 4);
        // V. 为闭包参数指定默认值
        // 定义闭包变量 , 声明两个参数 a, b
        // 并为闭包指定默认值
        def closure5 = { a = 0, b = "Groovy" ->
            println "${a} : ${b}"
        }
        // 闭包有默认值 , 调用时可以不传入参数
        closure5()
        // 从左到右绑定 闭包参数
        def closure6 = closure5.curry(1, "Gradle")
        // 闭包有默认值 , 调用时可以不传入参数
        closure6()
        // 从右到左绑定 闭包参数
        def closure7 =closure5.rcurry(2, "Java")
        // 闭包有默认值 , 调用时可以不传入参数
        closure7()
        // 从第 n 个参数开始绑定闭包参数 ,
        // 注意调用了 curry / ncurry / rcurry 方法后 , 之前的默认值就覆盖了
        // 此时第一个参数没有值了
        // 调用时 , 必须传入第一个参数只才可以
        def closure8 =closure5.ncurry(1, "Kotlin")
        // 闭包的第一个默认值被取消 , 此时必须传入第一个参数的值才能执行该闭包
        // 否则报错
        closure8(3)
    }
}

Accept One Arguments : Hello
Accept One Arguments : Hello
Not Accept Arguments
Not Accept Arguments
1
2
1 : 2
3 : 4
0 : Groovy
1 : Gradle
2 : Java
3 : Kotlin