groovy 的map类型对应java的LinkedHashMap

 闭包就是一个代码块。跟一个方法一样，可以有参数，可以没参数。可以被赋值给一个变量。也可以当做一个参数传递给一个方法，像普通方法一样调用。

groovy高级特性

闭包

goovy高级特性

groovy高级特性

通过def定义变量

assert断言

定义字符串  def  s1 = 'imooc'

 def s2 = "gradle version  is ${version}"可以插入变量

def s3 = ''' my name  is  hello'''  可以换行

集合  def bulidTools = ['ant' , 'maven']

追加  bulidTools <<'gradle'

闭包是一个代码块，可以有参数，可以没有参数

def c1 = {

v -> 

        print v

}

groovy高效特性

1. 可选的类型定义-> 不用定义类型，自动(弱类型)

   def version = 1

2. assert语句 [断言:此处应为error]

   assert version == 2

3. 括号可选

   println(version)

   println version

4. 字符串

   def s1 = 'fsdfsd'

   def s2 = "fafad"   [可以插入变量${xxxx}，直接解析]

   def s3= '''afafadf

   asfsdfsdffsdfsdfsdfsdfdf''' [换行]

5. 集合API

   //定义一个list，默认为array list

   def buildTools=["ant","maver"]

   //追加

   buildTools << 'dfsdfd'

   //验证

   assert buildTools.getClass() == ArrayList

   assert buildTools.size() == 3

   //定义一个map[一定要单引号吗]

   def buildYears = ['ant':2000, maven:2004]

   //追加元素

   buildYears.gradle = 2009

   //访问元素【两种形式】

   println buildYears.ant

   //字符串形式[一定要单引号吗]

   println buildYears['gradle']

   //打印类型[LinkedHashMap]

   println buildYears.getClass()

6. 闭包[代码块，多种使用形式]

   //常见gradle闭包形式，当做方法参数

   //箭头后面是 方法体
   

   def c1 = {

   v -> 

        print v

   }

   def c2 = {

          print 'hello'

   }

   //两个使用闭包作为参数的方法

   //不要导入java相关自动补全包

   def method1(Closure closure){

       closure('param')

   }

   
   

   //不带参数的闭包
   

   def methon2(Closure closure){

          closure()

   }

   //多了个分号????

   method1(c1);

   method2(c2);

   
   

//6 闭包
def c1 = {
    v ->
        println v
}
def c2 ={
    println 'hello'
}

def method1(Closure closure){
    closure('param')
}

def method2(Closure closure){
    closure()
}

method1(c1);
method2(c2);

//5 集合api
//list
def buildTools=['ant','maven']
buildTools << 'gradle'
assert buildTools.getClass() == ArrayList
assert buildTools.size() ==3
//map
def buildYears = ['ant':2000, 'maven':2004]
buildYears.gradle = 2009

println buildYears.ant
println buildYears['gradle']
println  buildYears.getClass()

//普通字符串

def s1 = 'imooc'

//可以添加变量的字符串

def s2 = "gradle version is ${version}"

//可以换行的字符串

def s3 = '''my name is

imooc'''

c1闭包包含一个参数v，它的类型是可以省略的，箭头后面就是一个方法体

闭包简单来说就是一个代码块，跟一个方法一样的，可以有参数可以没有参数。闭包可以被赋值给一个变量，也可以当成一个参数传递给一个方法，像普通方法一样调用

• groovy 的高级特性

1. 可选的类型定义， 系统会自动推断

2. assert 语句， 不会报       NullPointerException,

   1. 在任何地方都可以执行 assert

3. 括号是可选的

4. 字符串的三种定义形式

   1. 单引号

   2. 双引号， 可引用变量  ${}

   3. ''' String ''' ,        可换行

5. 集合api

   1. list

   2. map

6. 闭包

字符数组：def buildYears=['ant':2000,'maven':2004]

添加map数组：buildYears.gardle=2009

lise: def buildTools=['ant','maven']

 添加list:  buildTools << 'gradle'

gradle 弱类型的语言

1. 没有主函数,可以在任意地方写程序

2. 自定义类型 dev

3. 输出函数括号可选,一般建议带括号,便于识别

4. arrayList  写法  dev buildTools={"ant","maven"}   添加元素 buildtools << "gradle"

5. hashMap 写法 dev buildTools={"ant":2009,"maven":2010} 添加元素 buildTools="gradle":2018
   

6. 闭包的写法

groovy的集合和MAP的使用

向集合list中追加元素：

def mylist=['ant','maven']

mylist << 'gradle'

groovy里面的字符串：

单引号：常量字符串

双引号：可以加字符串变量

三引号：可以使字符串换行