groovy程序结构

定义包

包的定义和在 Java 中一样：

// defining a package named com.yoursite
package com.yoursite

导入包

1.导入包
将包里的类名导入后就可以直接使用类名，而不用再加限定名
// importing the class MarkupBuilder
import groovy.xml.MarkupBuilder

// using the imported class to create an object
def xml = new MarkupBuilder()

assert xml != null

2.默认导入:下面这些类在 Groovy 中已经被默认导入，可以直接使用
import java.lang.*
import java.util.*
import java.io.*
import java.net.*
import groovy.lang.*
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal

3.常规导入:简单导入就是常规导入
// importing the class MarkupBuilder
import groovy.xml.MarkupBuilder

// using the imported class to create an object
def xml = new MarkupBuilder()

assert xml != null

4.星号导入:星号导入可以一次性将包里的类全部导入,星号导入的问题是，导入的类名可能会和本地类名冲突
import groovy.xml.*

def markupBuilder = new MarkupBuilder()

assert markupBuilder != null

assert new StreamingMarkupBuilder() != null

5.静态导入:一般情况下，要使用类里面的静态方法或者静态属性，都要加上类名作为限定。
import static Boolean.FALSE

assert !FALSE //use directly, without Boolean prefix!

6.静态导入别名:静态导入的方法名字并不直观，可以用 as 给它起个别名.
import static Calendar.getInstance as now

assert now().class == Calendar.getInstance().class

7.星号静态导入:同样可以利用星号将类中的所有静态属性和静态方法一次性导入
import static java.lang.Math.*

assert sin(0) == 0.0
assert cos(0) == 1.0

8.给导入的类起别名。例如：给有错误的类起个别名，自己定义一个和原先同名的类，扩展原来错误的类，
并修正其中错误的方法。
import thirdpartylib.MultiplyTwo as OrigMultiplyTwo

class MultiplyTwo extends OrigMultiplyTwo {
    def multiply(def value) {
        return value * 2 // fixed here
    }
}

// nothing to change below here
def multiplylib = new MultiplyTwo()

// assert passes as well
assert 4 == new MultiplyTwo().multiply(2)

 脚本 VS 类

Groovy 可以向 Java 一样，用一个主类来启动程序，也可以直接运行一个脚本，例如Main.groovy脚本文件：

println 'Groovy world!'

 脚本被编译成类

脚本实际上总是被编译成一个类，类名和脚本名相同，代码都放置在run方法中。

import org.codehaus.groovy.runtime.InvokerHelper

class Main extends Script {                     
    def run() {                                 
        println 'Groovy world!'                 
    }
    static void main(String[] args) {           
        InvokerHelper.runScript(Main, args)     
    }
}

脚本中的方法

在脚本中可以定义方法
int fib(int n) {
    n < 2 ? 1 : fib(n-1) + fib(n-2)
}
assert fib(10)==89

方法的调用和定义都可以放在脚本中
println 'Hello'                                 
int power(int n) { 2**n }                       
println "2^6==${power(6)}" 

脚本中的方法实际上是在脚本类中定义，而所有的执行代码都是放在run方法中。上面的代码会被转换成下面这样：
import org.codehaus.groovy.runtime.InvokerHelper
class Main extends Script {
    int power(int n) { 2** n}                   
    def run() {
        println 'Hello'                         
        println "2^6==${power(6)}"              
    }
    static void main(String[] args) {
        InvokerHelper.runScript(Main, args)
    }
}

脚本中的变量

1.可以向 Java 中一样，先声明再使用：
int x = 1
int y = 2
assert x+y == 3

2.也可以直接使用一个没有声明的变量：
x = 1
y = 2
assert x+y == 3

用第一种方法声明的变量，不能在脚本中的方法中使用，在脚本外部也看不到。

用第二种方法声明的变量，可以在脚本中的方法中使用，在脚本外部也可以看到。

笔记出处：https://www.jianshu.com/p/1339ab4f35dd

原文出处：http://groovy-lang.org/syntax.html