关注我，这里有你意想不到的惊喜
数据类型
在Groovy中，数据类型有：
- Java中的基本数据类型
- Java中的对象
- Closure（闭包）
- 加强的List、Map等集合类型
- 加强的File、Stream等IO类型
标识符&方法
def 是 Groovy 用来定义标识符的关键字
// 定义一个字符串变量 domain 它的值为 君哥聊编程
def domain = "君哥聊编程";
//定义一个整数，a会自动被推导为整数类型
def a = 1;
//也可以指定具体类型
def int c = 1;
// 定义一个方法 buildString，接收两个字符串参数，返回它们拼接的结果
def buildString(String a, String b){
println "$a-$b"
}
// 结尾的分号可以省略
def result = buildString('hello' , 'it235')总结：
- 在Groovy中，类型是弱化的，所有的类型都可以动态推断，但是Groovy仍然是强类型的语言，类型不匹配仍然会报错
- Groovy中的注释和Java中相同
字符串
Groovy 中提供了三种表示 String 的方法：单引号（’），双引号（"）或三引号（’’’）括起来。
- 单引号括起来的字符串没有运算能力，表示普通字符串
- 双引号表示的字符串可以使用取值运算符${}，而$在单引号只只是表示一个普通的字符
三引号表示的字符串又称为模版字符串，可以跨越多行，它可以保留文本的换行和缩进格式，三引号同样不支持$
def stringTest() { def strA = '单引号' def strB = "双引号" def strC = ''' ---三引号--- ''' println strA println strB println strC println '单引号==$strB' println "双引号==$strB" println '''三引号==$strC''' } 输出结果 单引号 双引号 ---三引号--- 单引号==$strB 双引号==双引号 三引号==$strC
方法
括号可省略：调用方法的时候，可以省略括号，如 #2
def methodTest(){ buildString("君哥","牛皮") // #1 buildString "君哥","牛皮" // #2 } def buildString(String a, String b){ println "$a-$b" } methodTest() 输出结果： 君哥-牛皮 君哥-牛皮return 可不写： 方法中没有写 return 语句，则方法执行过程中的最后一句代码的值作为返回值
def methodTest(){ def result = chooseSmallNum 1,10 println result } def chooseSmallNum(int a, int b){ if (a <= b) { a }else { b } } methodTest() 输出结果： 1Groovy支持动态类型推导，使用def来定义变量和方法时可以不指定变量的类型和方法的返回值类型，同时定义方法时参数可以不指定类型
def num1 = 1 def num2 = 2 def result = add(num1, num2) def add(a, b){ return a + b }
运算符与逻辑控制
运算符与Java基本保持一致
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
逻辑控制
分支
// if条件语句 def age = 28 if (age >= 30) { println("${age}岁，不小了，该找女票了") } else { println("还小呢，继续玩,才${age}岁") } //if-else-if def age = 28 if (age >= 30) { println("${age}岁，不小了，该找女票了") } else if (age < 28 && age > 22) { println("还小呢，继续玩,才${age}岁") }else { println("${age}尴尬的年纪") } //swtich switch支持集合、支持闭包、支持正则 def x = 1.23 def result = "" switch ( x ) { case "foo": result = "found foo" // lets fall through case "bar": result += "bar" case [4, 5, 6, 'inList']: result = "list" break case 12..30: result = "range" break case Integer: result = "integer" break case Number: result = "number" break case ~/fo*/: // toString() representation of x matches the pattern? result = "foo regex" break case { it < 0 }: // or { x < 0 } result = "negative" break default: result = "default" }循环
//0 1 2 3 4 for(i = 0; i < 5; i++){ print i + ' ' } //0 1 2 3 4 5 for(i in 0..5){ print i + ' ' } //0 1 2 3 4 for(i in 0..<5){ print i + ' ' } //0 1 2 3 4 5.times{ print it + ' ' } //5 6 7 8 9 10 5.upto(10){ print it + ' ' } //5 4 3 2 5.downto(2){ print it + ' ' } //5 8 11 14 5.step(17,3){ print it + ' ' } //5 3 1 -1 -3 5.step(-4,-2){ print it + ' ' }
Bean
- Groovy会为类中每个没有可见性修饰符的字段生成
getter/setter方法，我们访问这个字段其实是调用它的getter/setter方法。 - 同时只要写了 getter/setter 方法，也一样可以作为属性进行访问。
- 对于没有定义的属性，如果只写了 getter 方法，那不可以修改该属性的值，如例子中的 age 属性；
class Person{
def name
private def country
def setNation(nation){
this.country = nation
}
def getNation(){
return country
}
public int getAge(){24}
public String getInfo(){
"$country-$name-$age"
}
}
def person = new Person()
//访问属性
person.name = '君哥'
println person.name
//像字段一样访问这个以get/set开头的方法
person.nation = "china"
println person.nation
//访问的是info的get方法
println person.info
输出结果：
君哥
china
china-君哥-24Collection
对于 List 来说，Groovy 提供下标索引的方式进行访问，值得注意的是，除了普通的下标索引，还有负下标索引和范围索引的方式
def listTest(){
def nameList = ["it235","君哥","Groovy","Java","Kotlin","js","Gradle"]
println nameList[0] // 正数第一个
println nameList[1] // 正数第二个
println nameList[-2] // 倒数第二个
println nameList[-1] // 倒数第一个
println nameList[0..2] // 正数第一个到第三个
println nameList[-1..1] // 倒数第一个到正数第二个，倒着打印
}
输出结果
it235
君哥
js
Gradle
[it235, 君哥, Groovy]
[Gradle, js, Kotlin, Java, Groovy, 君哥]Map在gradle中用得非常多，如：plugins中、dependencies中，map所有key默认都是string类型的。
//空Map声明
def mapNull = [:];
println mapNull.size();//0
def map = [
iPhone : 'iWebOS',
Android: '2.3.3',
Nokia : 'Symbian',
Windows: 'WM8'
]
println map instanceof HashMap
if(map.containsKey('Windows')){
println(map.Windows)
println(map['Windows'])
println map.get("Windows","default value")
}
// Print the values
map.each{ k, v -> println "${k}:${v}" }
for ( e in map ) {
print "key:${e.key},value:${e.value}"
}
输出结果：
0
true
WM8
WM8
WM8
iPhone:iWebOS
Android:2.3.3
Nokia:Symbian
Windows:WM8
key:iPhone,value:iWebOSkey:Android,value:2.3.3key:Nokia,value:Symbiankey:Windows,value:WM8闭包 Closure
闭包是Groovy中非常重要的一个数据类型，是由大括号括起来的一段可执行的代码，可以接受参数也可以有返回值。
- 闭包语义
{ [closureParameters -> ] statements }
其中[closureParameters->]代表参数列表，多参数用逗号分割，用->隔开参数与内容，没有参数可以不写-> 示例
//一段简单的输出代码块 {println "Hello Gradle"} //闭包只有一个参数的时候，默认就是 it，无需申明 {println it} //即使申明了it也不影响程序 {it -> println it} //将上述申明的it换成name，程序依然能读取到 {name -> println name} //多个参数且指定参数类型的闭包 {String a ,int b -> println "key:$a ,value:$b"} //多个参数未指定类型的闭包 {k,v -> println "$k-$v"}groovy.lang.ClosureAPI
每个定义的闭包是一个Closure对象，所以我们可以把一个闭包赋值给一个变量//接收简单类型的闭包对象 def simpleClosure = { println "Hello Gradle" } //接收带一个参数的闭包对象 def itClosure = { it -> println it } //接收带多个参数的闭包对象，且包含返回值 def paramClosure = { k,v -> println "$k-$v" return "hello closure" }执行闭包
行闭包对象有两种，一是直接用括号+参数，二是调用call方法- 闭包对象(参数)
- 闭包对象.call(参数)
simpleClosure() simpleClosure.call() itClosure("默认1个参数的闭包") itClosure.call("默认1个参数的闭包") def resultA = paramClosure("hello" , "world") def resultB = paramClosure.call("hello" , "world")复杂一点的调用
//闭包体作为参数传入，操作单个属性 def simpleCall(closure){ def value = "Hello Groovy" closure(value) } //作为参数传入 simpleCall({print it}) //去掉()的简写 simpleCall{ print it } //map遍历操作 def mapEach(closureTemp){ def map = ["君哥","it235.com","Gradle":"Groovy"] map.each { closureTemp(it.key,it.value) } } //调用mapEach方法，mapEach的参数就是闭包 mapEach { k,v -> // 闭包不只一个参数的时候，需要把参数一一列出 println "$k-$v" } // 方法 listEach 只有一个参数，用于接收一个闭包参数 def listEach(closureTemp){ def nameList = ["君哥","it235.com","Groovy","Java","Kotlin"] nameList.each { closureTemp(it) } } // listEach 的参数是闭包 listEach { // 闭包只有一个参数的时候，默认就是 it println it }
代码块可作为参数传递：代码块就是闭包，通俗来说就是一段被大括号包裹起来的代码
// Closure 定义闭包
def doSomething(String a, String b, Closure method){
method.call(a,b)
}
//方式1：初始写法，比较繁琐
doSomething("君哥聊编程","it235.com",{a,b -> println "$a-$b"})
//方式2：Groovy 规定如果方法的最后一个参数是闭包，可以放到方法后面
doSomething("君哥聊编程","it235.com"){ a,b ->
println "$a-$b"
}
//方式3：括号可以省略，最常见的写法
doSomething "君哥聊编程","it235.com",{ a,b ->
println "$a-$b"
}总结
本篇到这里就结束了，带大家认识和学习了groovy语法基础，用好gradle的前提是我们需要掌握Groovy基础语法，有了这一篇的知识，下一篇我们就来学习Gradle提供的内部API，循序渐进的成为大佬，有疑问可以在评论区留言讨论
