版权声明：本文由“勤劳的悄悄”翻译，并发布在“简书”网，转帖请保留该版权声明。
本章内容为 Groovy 程序结构部分。
[TOC]
1. 定义包
</p>
包的定义和在 Java 中一样：
// defining a package named com.yoursite
package com.yoursite
2.导入包
</p>
将包里的类名导入后就可以直接使用类名，而不用再加限定名
// importing the class MarkupBuilder
import groovy.xml.MarkupBuilder
// using the imported class to create an object
def xml = new MarkupBuilder()
assert xml != null
2.1.默认导入
</p>
下面这些类在 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
2.2.常规导入
</p>
简单导入就是常规导入
// importing the class MarkupBuilder
import groovy.xml.MarkupBuilder
// using the imported class to create an object
def xml = new MarkupBuilder()
assert xml != null
2.3.星号导入
</p>
星号导入可以一次性将包里的类全部导入
import groovy.xml.*
def markupBuilder = new MarkupBuilder()
assert markupBuilder != null
assert new StreamingMarkupBuilder() != null
星号导入的问题是，导入的类名可能会和本地类名冲突
2.4.静态导入
</p>
一般情况下，要使用类里面的静态方法或者静态属性，都要加上类名作为限定。
使用静态导入后可以直接将类中的静态方法和静态属性导入到名字空间中，可以直接使用。
import static Boolean.FALSE
assert !FALSE //use directly, without Boolean prefix!
2.5.静态导入别名
</p>
有时候静态导入的方法名字并不直观，可以用 as 给它起个别名
import static Calendar.getInstance as now
assert now().class == Calendar.getInstance().class
2.6.星号静态导入
</p>
同样可以利用星号将类中的所有静态属性和静态方法一次性导入
import static java.lang.Math.*
assert sin(0) == 0.0
assert cos(0) == 1.0
2.7.给导入的类起别名
</p>
常规导入的类也可以起别名，常用在下面的场景中。
下面有一个第三方的包，其中MultiplyTwo方法的意思是乘以2，但是代码理却错误的乘以了3
package thirdpartylib
public class MultiplyTwo {
def static multiply(def value) {
return value * 3 //故意乘错数字
}
}
我们在很多地方像下面这样使用了这个错误方法
def result = new MultiplyTwo().multiply(2)
因为是第三方包，我们无法修改原始代码。但是我们可以用类别名来解决这个问题：
- 给有错误的类起个别名
- 自己定义一个和原先同名的类，扩展原来错误的类
- 并修正其中错误的方法
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)
3.脚本 VS 类
</p>
3.1.主类 VS 脚本
</p>
Groovy 可以向 Java 一样，用一个主类来启动程序
Main.groovy
class Main {
static void main(String... args) {
println 'Groovy world!'
}
}
也可以直接运行一个脚本
Main.groovy
println 'Groovy world!'
3.2.脚本类
</p>
脚本实际上总是被编译成一个类，类名和脚本名相同，代码都放置在run方法中
Main.groovy
import org.codehaus.groovy.runtime.InvokerHelper
class Main extends Script {
def run() {
println 'Groovy world!'
}
static void main(String[] args) {
InvokerHelper.runScript(Main, args)
}
}
3.3.方法
</p>
在脚本中可以定义方法
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)
}
}
3.4.变量
</p>
可以向 Java 中一样，先声明再使用：
int x = 1
int y = 2
assert x+y == 3
也可以直接使用一个没有声明的变量
x = 1
y = 2
assert x+y == 3
用第一种方法声明的变量，不能在脚本中的方法中使用，在脚本外部也看不到。
用第二种方法声明的变量，可以在脚本中的方法中使用，在脚本外部也可以看到。
