Groovy基础语法

1.实现循环的方式

1.for in

for(i in 0..2){
   print 'hello world'
}

2. upto

0.upto(2){
    print '$it'
}

3.times

3.times{
    print '$it'
}

安全导航操作符

1.null检查处理

def foo(str){
    str?.reverse()
}

println foo('evil')
println foo(null)
输出结果为
live
null

使用？.在空引用上调用reverse(),其结果产生了一个null，而没有抛出空指针异常

基础语法

1.return语句总是可选的

int add(a,b){
     a+b
}
等同于
int add(a,b){
    return a+b
}

2.分号分隔语句总是可选的
3.方法和类默认为public
4.？.操作符只有对象引用不为空时才分派调用
5.函数引用可以不加（）

def variable1 = 1   //可以不使用分号结尾  
def varable2 = "友盟分享"  
int x = 1  //变量定义时，也可以直接指定类型
println 'hello world' //引用println函数

String

1.单引号''中的内容严格对应Java中的String，不对$符号进行转义

defsingleQuote='I am $ dolloar'  //输出就是I am $ dolloar

2.双引号""的内容则和脚本语言的处理有点像，如果字符中有$号的话，则它会$表达式先求值。

def aaa = "aaa" //输出aaa
def x = 1  
def result = "I am $x person" //输出I am 1 person

3.三个引号'''xxx'''中的字符串支持随意换行 比如

   defmultieLines = ''' begin  
     line  1  
     line  2  
     end '''

函数

1.可选形参

def log(x,base=10){
    x*base
}
println 11
println 11,100
println 100,10
如输出结果所示，Groovy使用可选形参填充了缺失的实参
110
1100
1000

2.多赋值

def spilteName(fullName){fullName.spilt(' ')}

def(firstName,secondName) = spilteName('James Bond')
println "$secondName $firstName $secondName"
如输出所示
Bond James Bond

动态类型

1.静态类型

def takeHelp(Man man){
    man.help()
}

class Man{

    def help(){
        println 'man help'
    }
}

2.动态类型

def takeHelp(man){
    man.help()
}

class Man{

    def help(){
        println 'man help'
    }
}

class Women{
    def help(){
        println 'women help'
    }
}

class Elephant{
    def help(){
        println 'elephant help'  
    }
}
下面调用takeHelp()
takeHelp(new Man())
takeHelp(new Women())
takeHelp(new Elephant())
如下输出所示
man help
women help
elephant help

闭包

def pikeEven(n,block){
    for(int i=2;i<n:i+=2){
         block(i)
    }
}

pickEvent(10){number-> println(number)}

容器类

Groovy中的容器类很简单，就三种：
List：链表，其底层对应Java中的List接口，一般用ArrayList作为真正的实现类。
Map：键-值表，其底层对应Java中的LinkedHashMap。
Range：范围，它其实是List的一种拓展。
下面会举一些例子：
List

def aList = [5,'string',true] //List由[]定义，其元素可以是任何对象  
变量存取：可以直接通过索引存取，而且不用担心索引越界。如果索引超过当前链表长度，List会自动  
往该索引添加元素  
assert aList[1] == 'string'  
assert aList[5] == null //第6个元素为空  
aList[100] = 100 //设置第101个元素的值为10  
assert aList[100] == 100  
那么，aList到现在为止有多少个元素呢？  
println aList.size  ===>结果是101

Map

def aMap = ['key1':'value1','key2':true]  
/*Map由[:]定义，注意其中的冒号。冒号左边是key，右边是Value。key必须是字符串，value可以是任何对象。另外，key可以用''或""包起来，也可以不用引号包起来。比如  */
def aNewMap = [key1:"value",key2:true]//其中的key1和key2默认被  
处理成字符串"key1"和"key2"  
/*不过Key要是不使用引号包起来的话，也会带来一定混淆，比如  */
def key1="wowo"  
def aConfusedMap=[key1:"who am i?"]  
/*aConfuseMap中的key1到底是"key1"还是变量key1的值“wowo”？显然，答案是字符串"key1"。如果要是"wowo"的话，则aConfusedMap的定义必须设置成：  */
def aConfusedMap=[(key1):"who am i?"]  
/*Map中元素的存取更加方便，它支持多种方法：  */
println aMap.keyName  //  <==这种表达方法好像key就是aMap的一个成员变量一样  
println aMap['keyName']// <==这种表达方法更传统一点  
aMap.anotherkey = "i am map"  //<==为map添加新元素

Rang

def aRange = 1..5 //<==Range类型的变量 由begin值+两个点+end值表示左边这个aRange包含1,2,3,4,5这5个值  如果不想包含最后一个元素，则  
def aRangeWithoutEnd = 1..<5  //<==包含1,2,3,4这4个元素  
println aRange.from  
println aRange.to