Groovy入门经典 随书重点

Posted 2020-07-22

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

　　　

1 ‘He said "Hello"!‘
2 ‘He said \"Hello\"!‘

 

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

1 def age=25
2 ‘My age is ${age}‘    //My age is ${age}
3 "My age is ${age}"    //My age is 25
4 """//My age is ${age}"""    //My age is 25
5 """My 
6 age 
7 is \${age}"""    //My age is ${age}

 

解释用双，其他用单

2.2字符串索引和索引段

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

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

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

 

2.3基本操作

字符串不可变

等同于java

1 def greeting=‘Hello world‘
2 ‘Hello‘+‘world‘        //Helloworld
3 ‘Hello‘*3            //HelloHelloHello
4 greeting-‘o world‘    //Hell
5 greeting.size()        //11
6 greeting.length()    //11
7 greeting.count(‘o‘)        //2
8 greeting.contains(‘ell‘)    //true

 

2.4字符串方法

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

 

2.5比较字符串

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

2.6正则表达式

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

   def regex=~’cheese’

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

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

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

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

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

 

3列表、映射和范围

3.1列表

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

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

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

    

[]调用List类的#getAt

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

 

类似于前面的String访问

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

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

3.2映射

类似于java的Map

1. 访问 调用#getAt

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

    

2. 赋值 调用#putAt

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

    

3. 声明

   [:] 空映射

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

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

 

3.3映射方法

1 def map=[‘ken‘:2745,‘john‘:2746,‘sally‘:2742]
2 map.get(‘david‘,9999)    //9999
3 map.get(‘sally‘)        //2742
4 map.keySet()            //[david,ken,sally,john]
5 mp[‘ken‘]                //2745
6 mp.values.asList()

 

3.4范围

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

 

4基本输入和输出

4.1基本输出

 1 print "My name is"
 2 print("MaYiwen")
 3 println()
 4 //My name is MaYiwen
 5 def age=25
 6 prinln "My age is:{age}"
 7 
 8 def numbers=[1,2,3,4]
 9 def staffTel=[‘ken‘:2745,‘john‘:2746,‘jessie‘:2772]
10 println "Numbers:${numbers}"
11 println "Staff telephone:${staffTel}"
12 //Numbers:[1,2,3,4]
13 //Staff telephone:[‘ken‘:2745,‘john‘:2746,‘jessie‘:2772]

 

4.2格式化输出

1 printf

 

类似java

5 方 法

5.1 方法

类似js 方法没有返回值

5.2 方法参数

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

1 def methodName(para1,para2,para3){}

 

5.3 默认参数

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

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

 

5.4 方法返回值

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

5.5 参数传递

值传递

类似于java

5.6 作用域

5.7 集合作为参数和返回值

流程控制

6.1 while语句

类似于java

6.2 for语句

类似于java

7类

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

1 class Account{
2     def number
3     def balance
4 }
5 def accounts=[new Account(number:‘abc123‘,balance:1200),
6 new Account(number:‘pqr456‘,balance:200)]
7 accounts.each{acc->println acc}

 

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

 1 class Account{
 2     def number
 3     def balance
 4     def Account(number,balance){
 5         this.number=number
 6         this.balance=balance
 7     }
 8 }
 9 def accounts=[new Account(‘abc123‘,1200),new Account(‘pqr456‘,200)]
10 def account=new Account(number:‘abc123‘,balance:1200)//报错

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