Groovy入门经典 随书重点

1 数值和表达式

1.1数值

1. 整数是Integer类的实例
2. 有小数部分的数值是BigDecimal类的实例

不同于java，没有基础数据类型 
一切皆对象的概念重于java

1.2表达式

1. 两个整数的除法运算通常会产生一个浮点数
2. 获得两个整型值相除的整数部分，使用#intdiv
3. 浮点数取模非法

1.3运算优先级

*/% 优先于 +-

1.4赋值

1. def先声明变量，后使用

   等同于js，弱类型

2. 标识符 和java一样的命名规则

1.5自增和自减运算符

类似于java

1.6对象引用

动态类型

变量引用的类型是在运行时确定，而不是在编译时，类似于java的多态 
也有垃圾回收机制，类似于java的

1.7关系运算符和等于运算符

关系运算符：< <= > >=通过#compareTo实现 
等于运算符：== !=调用#equals <=>调用#compareTo

都是调用某个方法实现

2字符串和正则表达式

2.1字符串字面值

单引号：所见即所得 
双引号：解释性字符串 
三引号：解释性字符串 多行文本用这个

单双引号可混在一起使用，类似js；也可以使用\进行转义，类似java

　　　

 'He said "Hello"!'
 'He said \"Hello\"!'

解释性字符串中的${expression}都将被求值，结果作为字符串的一部分

 def age=25
 'My age is ${age}'    //My age is ${age}
 "My age is ${age}"    //My age is 25
 """//My age is ${age}"""    //My age is 25
 """My
 age
 is \${age}"""    //My age is ${age}

解释用双，其他用单

2.2字符串索引和索引段

字符串是顺序排列的字符集合

索引类似于java String的#charAt 
获取指定位置的字符类似于数组

 def greeting='Hello World'
 greeting[4]        //o
 greeting[-1]    //d
 greeting[1..2]    //el
 greeting[1..<3]        //el
 greeting[4..2]        //oll
 greeting[4,1,6]        //oew

2.3基本操作

字符串不可变

等同于java

 def greeting='Hello world'
 'Hello'+'world'        //Helloworld
 'Hello'*3            //HelloHelloHello
 greeting-'o world'    //Hell
 greeting.size()        //
 greeting.length()    //
 greeting.count('o')        //
 greeting.contains('ell')    //true

2.4字符串方法

 def message='Hello'
 message.center(11)    //返回长度为11，左右两边均使用空格填充的字符串
 message.center(3)
 message.center(11,'#')
 message.eachMatch('.')

2.5比较字符串

== 调用#equals 
<==> 调用#compareTo

2.6正则表达式

1. ~’regex’定义正则表达式

   def regex=~’cheese’

2. if(‘cheesecake’=~’cheese’) //左边String对象和右边的正则匹配，返回布尔值

==~ 精确匹配 ‘cheesecake’==~’cheese’

\\\\在正则中表示一个反斜杠字符

类似于java中正则的使用，用单引号括起 
也可以用js的方法，直接使用，不用引号

 def matcher="\$abc."=~\\\$(.*)\\.
 def matcher="\$abc."=~/\$(.*)\./

3列表、映射和范围

3.1列表

类似于java的List，增加了一些自己的方法

1. 列表对象和访问列表元素

    def numbers=[11,12,13,14]
    number[0] //11
    number[-1] //

[]调用List类的#getAt

 number[0..2]    //[11,12,13]
 number[1..<3]    //[12,13]

类似于前面的String访问

包含边界的索引范围访问，产生一个新的列表对象

 <<  把新元素追加到列表末尾 调用#leftShift
 +   连接两个列表          调用#plus
 -   从列表删除元素        调用#minus
 number[1]=[33,44]        调用#putAt

3.2映射

类似于java的Map

1. 访问 调用#getAt

    def names=[‘ken’:’Barclay,’John’:’Savage’]
    def divisors=[4:[2],6:[3,2],12:[6,4,3,2]]
    names[‘Ken’] //第一种访问写法
    names.Ken //第二种访问写法
    divisors[6]

2. 赋值 调用#putAt

    divisors[6]=[6,3,2,1]

3. 声明

   [:] 空映射

如果某个元素的关键字是变量，将被解释成一个String

 def x=1
 def y=2
 def m=[x:y,y:x]   //m=['x':2,'y':1]

3.3映射方法

 def map=['ken':2745,'john':2746,'sally':2742]
 map.get('david',9999)    //
 map.get('sally')        //
 map.keySet()            //[david,ken,sally,john]
 mp['ken']                //
 mp.values.asList()

3.4范围

 def twentiethCentury=1900..1999
 def reverseTen=10..1
 twentiethCentury.size()
 twentiethCentury.get(0)
 twentiethCentury.getFrom()
 twentiethCentury.getTo()
 twentiethCentury.contains(2000)
 twentiethCentury.subList(0,5)
 reverseTen[]2
 reverseTen.isReverse

4基本输入和输出

4.1基本输出

 print "My name is"
 print("MaYiwen")
 println()
 //My name is MaYiwen
 def age=25
 prinln "My age is:{age}"

 def numbers=[1,2,3,4]
 def staffTel=['ken':2745,'john':2746,'jessie':2772]
 println "Numbers:${numbers}"
 println "Staff telephone:${staffTel}"
 //Numbers:[1,2,3,4]
 //Staff telephone:['ken':2745,'john':2746,'jessie':2772]

4.2格式化输出

 printf

类似java

5 方 法

5.1 方法

类似js 方法没有返回值

5.2 方法参数

参数不需要指明类型，只需要在括号中放变量名就可以

 def methodName(para1,para2,para3){}

5.3 默认参数

方法中的形参可以指定为默认参数

 def someMethod(para1,para2=0,para3=0){}
 someMethod方法可以通过一个、两个或者三个实参调用，至少提供一个实参

5.4 方法返回值

return 可选，省略了，代码的最后一条语句的值就是方法的返回值

5.5 参数传递

值传递

类似于java

5.6 作用域

5.7 集合作为参数和返回值

流程控制

6.1 while语句

类似于java

6.2 for语句

类似于java

7类

getter和#setter都是groovy类的隐含方法

 class Account{
     def number
     def balance
 }
 def accounts=[new Account(number:'abc123',balance:1200),
 new Account(number:'pqr456',balance:200)]
 accounts.each{acc->println acc}

在java中，account类通常包含初始化类对象的构造器方法。在groovy中并不需要做次工作，只需要使用new操作符和指定的参数即可替代。 
在groovy中同样也有构造器方法。

 class Account{
     def number
     def balance
     def Account(number,balance){
         this.number=number
         this.balance=balance
     }
 }
 def accounts=[new Account('abc123',1200),new Account('pqr456',200)]
 def account=new Account(number:'abc123',balance:1200)//报错

类似于java，提供构造器会覆盖默认构造器，所以上面第10行调用默认构造器的代码报错