Groovy语法

注释

• 单行注释//

//这是单行注释

• 多行注释/**/

/*这是多行注释*/

// GroovyDoc注释/** */

/**
* 这是文档注释
*/

变量名

• 普通变量名和Java规则一样
• 引用变量，变量点后面可以跟引用值，可以使用java不允许的符号比如破折号等,比如

map = [:]
map."name" = "james"
map."a-b-c" = "dota"

map./slashy string/
map.$/dollar slashy string/$

def firstname = "Homer"
map."Simpson-${firstname}" = "Homer Simpson"

字符串

• 单引号字符串

'hello world'

• 三引号字符串表示多行

""" line 1
line 2
line 3

• 双引号字符串，可以使用或者{}在字符串中进行插值，其中${}可以插入值或者表达式,但是表达式必须要以某种形式返回值否则值为null。
  其中$只对a.b有效，对其他语句无效如方法调用,大括号等，如果想输入$符号可以使用""

"2 + 3 is ${2+3}" // output 2+3 is 5
"2 + 3 is ${def i = 2; def j = 3; i+j}" // output 2 + 3 is 5

def person = [name: 'James', age: 36]
"$person.name is 36" // output James is 36
"person is $def age = 10" // 不合法
""

• 当字符串中存在${->}形式，这表示一个闭包，闭包包含0个参数或者1个参数
  0个参数的闭包会调用toString()作为值,即->后面的值会toString，如果是表达式必须要有返回值，否则为null
  1个参数的闭包会传入的参数类型为StringWriter，用这个参数可以追加内容, 可以使用"<<"操作符追加内容

def person = "1 + 2 is ${->3}"

def person = "1 + 2 is ${w -> w.append("5")}"
def person = "1 + 2 is ${w -> w << "5"}"

• 上述两种插值方法对比，采用闭包的好处可以动态更新数据，如果变量值更新了，闭包所用参数也对应更新。
  如下所示可以看出，当num值更新时，字符串闭包内的值也改变了， 普通传值没有改变是因为创建String的时候值就已经确定了。

def num = 3
def normal = "1 + 2 is ${-> num}"
def cls = "1 + 2 is ${num}"
println(normal) // output "1 + 2 is 3"
println(cls) // output "1 + 2 is 3"

num = 5
println(normal) // output "1 + 2 is 3"
println(cls) // output "1 + 2 is 5"

• 字符串使用插值，类型则会被转换为GString，类型，值得注意的是GString类型的hashCode和String类型的hashCode是不一样的

def key = "a"
map = [${key}:"James"]
printfln map["a"] // output null

• Char类型可以用以下三种来表示

def a = 'A'

def b = 'A' as char

def c = (char)'A'

Numbers

• 整数数据类型基本和Java一样分别是byte、short、char、int、long、BigInteger
  如果类型修饰符为def，会根据范围，自动识别对应的数据类型

  def i = 10
  println i instance of Interger // Output ture
  

• 小数数据类型分别是float、double、BigDecimal

  float a = 1.2
  double b = 1.21
  

• 数字可以添加下划线，使某些大数看起来更加清楚

long i =  1223_123_1L
long i = 0x7fff_8fff_0000_ffff

• 通过数字后缀来代表数据类型

Integer a = 42I或42i
Long b = 42L或42l
BigInteger c = 42G或42g
Double d = 42.2D或42.5d
Float e = 42.2F或42.1f
BigDecimal f = 42.24G或42.24g

List

• Groovy使用逗号分隔值（用方括号括起来）来表示列表，默认类型为List, 一个List的值可以是不同类型

def listone = [1,2,3,4]
def listtwo = [1, 1.24, "hello"]s

• List是ArrayList的实例，可以通过as进行转换成其他类型的List

def list = [1,2,3,4] as LinkedList

• List索引可以使用以下几种形式， 可以用<<添加值

def list = [1,2,3,4]
list[-1]
list[2]
list[1..3]

list << 5

• 多维List

list = [[0,1],[2,3]]
list[0][1]

Arrays

• Arrays的形式上和List是一样的，但是如果需要Arrays类型数据，需要通过变量指定数据类型或者通过as强转

int[] list = [1,2,3,4,5]
def list = [1,2,3,4] as int[]

• 索引，多维数组等定义和List一样
  
  

Maps

• Groovy使用逗号分隔值（用方括号括起来），键值对冒号分隔来表示Map

def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']

colors['pink'] = '#FF00FF'
colors.yellow = '#FFFF00'

• 如果想要引用变量作为key值，则需要加上括号

def key = 'pink'
def map = [(key) :123]

操作符

• ** 表示次方, 下面表示2的3次方

def num = 2 ** 3

• 双目运算符?:,是一个false 赋值

def a = 8
def b = a < 7 ?:10
// 等价于
if(a < 7) {
    b = ture
} else {
    b = 10
}

• *.操作符，将cars中make元素全部收集到同一个列表

class Car {
    String make
    String model
}
def cars = [
       new Car(make: 'Peugeot', model: '508'),
       new Car(make: 'Renault', model: 'Clio')]       
def makes = cars*.make                                
assert makes == ['Peugeot', 'Renault'] 

• Spread操作符可以将list列表中值传入符合list数量的方法中, 也可以直接插入到另外一个list中

def list = [1,2,3]
int f(int i, int j, int z) {
    return i * j + z
}

f(*list)

def other = [4,5, *list] // output [4,5,1,2,3]
def other = [4,5, list] // output [4,5,[1,2,3]]

• map中也可以使用

def map = [red : 0x1]
def add = [green : 0x2, * : map]
// output [green:34, red:17]

• Range操作符.., 生成一个有序列表

def i = 0..5 // output [0,1,2,3,4,5]
def i = 0..<5 // output [0,1,2,3,4]
def i = 'a'..'d' // output ['a','b','c','d']

• 比较操作符<=>, 类似java中的compareTO方法，

(1<=>1) = 0
(2<=>1) = 1
(2<=>3) = -1

• 下标操作符,类似getAt()或putAt()方法

def list = [0,1,2,3,4]
list[3] = 5 // output [0,1,2,5,4]
list[4] // output 4

• 成员关系操作符in，判断一个数据成员是否在列表当中

def list = [1,2,3]
5 in list // output false

• Identity操作符，==操作符在Groovy和Java中使用是不一样的， ==比较是值是否相等，equals比较的是内存地址是否一样

def list1 = [1,2,3]
def list2 = [1,2,3]
list1.is(list2) // output false
list1 == list2 // output true

Integer a = new Integer(5);
Integer b = new Integer(5);
println a.is(b) // output false
println a == b // output true

• 转换操作符as，as操作符如果符合转换规则，就可以转换，否则会抛异常。如果转换为另外一个类型就会创建一个新的对象

Integer x = 123 as String  // output "123"
String a = "123" as Map // 抛异常

• Groovy支持运算符重载
  
  

包

• 包支持用别名

import java.util.Date as SQLDate

SQLDate date = new SQLDate() 

• 脚本和类，Groovy会把脚本转换成一个类，这个类继承于Script，最终调用的还是main()方法,我们在写脚本中写的方法会被加入到类中，写的语句全部在run()方法中。

println 'Hello'                                 
int power(int n) { 2**n }                       
println "2^6==${power(6)}"

// 转换之后
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)
    }
}

• 脚本中变量作用域。
  变量如果声明类型，则无法被其他方法访问，因为这个变量相当于run方法中的局部变量
  变量如果没有声明类型，则会被脚本绑定，脚本会和其他方法共享这些数据

int declared  = 0
undeclared  = 10
void pow() {
    println declared
    println undeclared
}

pow()

• 反编译之后的代码, 可以看到run方法中会把变量值传入，pow方法中把值取出来

public class Study extends Script
{
  public void pow()
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray();
    arrayOfCallSite[2].callCurrent(this, arrayOfCallSite[3].callGroovyObjectGetProperty(this));
    arrayOfCallSite[4].callCurrent(this, arrayOfCallSite[5].callGroovyObjectGetProperty(this));
  }
  
  public Object run()
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray();
    int declared = 0;
    int i = 10;
    ScriptBytecodeAdapter.setGroovyObjectProperty(Integer.valueOf(i), Study.class, this, (String)"undeclared");
    pow();
   }
  
  public static void main(String... args)
  {
    CallSite[] arrayOfCallSite = $getCallSiteArray();
    arrayOfCallSite[0].call(InvokerHelper.class, Study.class, args);
  }
  
}

方法和类

• 如果没有可见修饰符修饰，默认是public的,并且会自动转换成属性，自然省去get和set方法

public class Study {
    public String name;

    class School {
        Study study = new Study();
        public void driver() {
        }
    }
}

• 一个文件可以包含多个类，如果没有类默认是脚本（当然最后还是会转换为一个类）

• 不论是构造函数还是普通函数参数都可以通过列表传入, 方法参数可以设置默认值

public class Study {
    public Study(String name, int age) {
        
    }
    
    public void pow(int a, int b = 9) {
    }
}


Study study = ["1",2] 
study.pow([5,6])
study.pow(5)

• 方法可变参数列表
  可以传入任意个参数
  T[]和T..是等价的，也表示可见参数，意味方法参数列表为数组的，都表示可变参数。
  如果出现多个方法重载，比如一个方法参数列表是可见参数，另外一个方法参数列表是具体个数参数，以含具体个数参数方法为主

  void f(int[] a);
  void f(int a);
  
  f(1) // 调用的是f(int a)方法
  

Traits(特征)

• 是Groovy独有的面向对象特性，有几点特性：由行为构成、可以实现接口、行为可以重载，兼容静态类型的检查和编译。可以看成具有方法实现和状态的接口，关键字trait

trait FlyingAbility {                           
    String fly() {
        println "I'm flying!" 
    }          
}

class Bird implements FlyingAbility {}          
def b = new Bird()                              
println b.fly()  

• 可以含有抽象方法

trait Greetable {
    abstract String name()                              
    String greeting() { "Hello, ${name()}!" }           
}

• 可以定义private方法

trait Greeter {
    private String greetingMessage() {                      
        'Hello from a private method!'
    }
    String greet() {
        def m = greetingMessage()                           
        println m
    }
}

• 可以使用this操作符

public trait FlyingAbility {
    
    String fly() {
        return this
    }
}

• 可以定义属性

trait Named {
    String name                             
}

• 可以定义私有和共有字段

trait Counter {
    public int num = 1
    private int count = 0                   
    int count() { count += 1; count }       
}

• 和接口一样支持多重继承

trait FlyingAbility {                           
        String fly() { "I'm flying!" }          
}
trait SpeakingAbility {
    String speak() { "I'm speaking!" }
}

class Duck implements FlyingAbility, SpeakingAbility {}

• 方法可以被覆盖、相互继承

trait FlyingAbility {                           
        String fly() { 
            "I'm flying!" 
        }          
}
trait SpeakingAbility extends FlyingAbility {
    String fly() {
        "I can speaking!" 
    }
}

闭包

• 闭包是一个匿名函数，拥有函数的特征，写法如下{ [closureParameters -> ] statements }, 有以下几种写法

{ item++ }                                          

{ -> item++ }                                       

{ println it }                                      

{ it -> println it }                                

{ name -> println name }                            

{ String x, int y ->                                
    println "hey ${x} the value is ${y}"
}

{ reader ->                                         
    def line = reader.readLine()
    line.trim()
}

• 闭包作为一个对象,是groovy.lang.Closur一个实例，可以赋值给该类的实例对象

def listener = { e ->  e } 
println listener //output `groovy.lang.Closure`对象
println listener("lis") // output  "lis"

Closure callback = { println 'Done!' }     

Closure<Boolean> isTextFile = {
    File it -> it.name.endsWith('.txt')                     
}

• 闭包可以像其他方法一样被调用，可以像其他函数一样传参进入，也可以当成一个对象调用call方法

def isOdd = { 
    int i -> i%2 != 0 
}

isOdd(2)
isOdd.call(2)

• 闭包跟函数一样，参数列表可以是对象，基本类型，可选列表，也可以给参数设置默认值，
  不过和函数不同的地方，如果闭包没有确切定义一个参数列表，闭包就会定义一个隐式参数it

def f = {-> printfln it}
def f = {it -> println it}

闭包中的this,owner,delegate

• this：在一个类中定义闭包，闭包中的this指向该类，
  getThisObject()和this是等价的。
  类中定义闭包使用this，则指向内部类,在该闭包中可以调用该类的成员变量和方法
  闭包中嵌套使用闭包，this也是指向类
  总之，无论闭包怎么嵌套，闭包中使用this就指向离他最近的类

class Enclosing {
    void run() {
        def whatIsThisObject = { getThisObject() }          
        assert whatIsThisObject() == this                   
        def whatIsThis = { this }                           
        assert whatIsThis() == this   //  等价                     
    }
}
class EnclosedInInnerClass {
    class Inner {
        Closure cl = { this }                               
    }
    void run() {
        def inner = new Inner()
        // 内部类定义闭包使用this，则指向内部类
        assert inner.cl() == inner                      
    }
}
class NestedClosures {
    void run() {
        def nestedClosures = {
            def cl = { this }                               
            cl()
        }
        // 闭包嵌套闭包，则this也指向类
        assert nestedClosures() == this                     
    }
}

• owner: 指向一个封闭的对象，可以是一个类或者闭包
  owner和getOwner()是等价的
  如果闭包定义在内部类中，指向的也是这个内部类
  但是如果owner在嵌套闭包内，则指向的是outer闭包，并非和this一样是类
  总结：和this一样都是返回封闭对象，但是this值包含类，owner包含了闭包和类

• delegate: 委托可以被赋值成定义的任何对象，默认情况下，delegate和owner的指向范围一样
  但是区别是delegate可以被赋于其他对象，而owner则不行

  class Person {
    String name
  }
  class Thing {
    String name
  }
  def p = new Persong(name: "Normal")
  def t = new Thing(name : "Teapot")
  
  def a = { 
    delegate.name.toUpperCase() 
  }
  
  def b = {
    owner.name.toUpperCase()
  }
  
  a.delegate = p 
  a() // output NORMAL
  b.owner = t 
  b() //报错，因为不允许被转为t对象