【Groovy】循环控制 ( Number 注入函数实现循环 | times 函数 | upto 函数 | downto 函数 | step 函数 | 闭包作为最后参数可写在外面 )（一）

/**
     * 从零开始多次执行闭包。每次都将当前索引传递给闭包。
     * Example:
     * <pre>10.times {
     *   println it
     * }</pre>
     * Prints the numbers 0 through 9.
     *
     * @param self    a Number
     * @param closure 闭包要调用多次
     * @since 1.0
     */
    public static void times(Number self, @ClosureParams(value=SimpleType.class,options="int")  Closure closure)

// 循环 10 次 , 每次获取获取当前循环的此处 , 取值 0 ~ 9
        // Groovy 向 Number 类中注入的 times 方法
        println ""
        print "( 7 ) : "
        10.times {
            // Integer it 就是每次的循环次数
            print it + " "
        }

( 7 ) : 0 1 2 3 4 5 6 7 8 9

/**
     * 从该数字迭代到给定的数字（含），每次递增一。
     *
     * @param self    a Number
     * @param to      another Number to go up to
     * @param closure the closure to call
     * @since 1.0
     */
    public static void upto(Number self, Number to, @ClosureParams(FirstParam.class) Closure closure)

// Groovy 向 Number 类中注入的 upto 方法
        println ""
        print "( 8 ) : "
        10.upto(20, {
            // Integer it 就是每次的循环次数
            print it + " "
        })

( 8 ) : 10 11 12 13 14 15 16 17 18 19 20

/**
     * 从这个数字迭代到给定的数字，每次递减一。
     *
     * @param self    a Number
     * @param to      another Number to go down to
     * @param closure the closure to call
     * @since 1.0
     */
    public static void downto(Number self, Number to, @ClosureParams(FirstParam.class) Closure closure)

// Groovy 向 Number 类中注入的 downto 方法
        println ""
        print "( 9 ) : "
        20.downto(10, {
            // Integer it 就是每次的循环次数
            print it + " "
        })

( 9 ) : 20 19 18 17 16 15 14 13 12 11 10

/**
     * 使用步长增量从该数字迭代到给定数字。每个中间编号都传递给给定的闭包。例子：
     * <pre>0.step( 10, 2 ) {
     *   println it
     * }</pre>
     * Prints even numbers 0 through 8.
     *
     * @param self       a Number to start with
     * @param to         a Number to go up to, exclusive
     * @param stepNumber a Number representing the step increment
     * @param closure    the closure to call
     * @since 1.0
     */
    public static void step(Number self, Number to, Number stepNumber, Closure closure)

// Groovy 向 Number 类中注入的 step 方法
        println ""
        print "( 10 ) : "
        10.step(30, 2, {
            // Integer it 就是每次的循环次数
            print it + " "
        })

( 10 ) : 10 12 14 16 18 20 22 24 26 28