当前位置：网站首页>Gradle学习（二）Groovy

Gradle学习（二）Groovy

2022-08-10 05:35:00 【丶咸鱼】

Groovy

Groovy是一门jvm语言，它最终是要编译成class文件然后在jvm上执行，所以Java语言的特性Groovy都支持，我们完全可以混写Java和Groovy。
Groovy的优势：Groovy提供了更加灵活简单的语法，大量的语法糖以及闭包特性可以让你用更少的代码来实现和Java同样的功能。

Groovy的变量和方法声明

def a = 1
def b = "hello world"
def int c = 1
 
def hello() {
   println ("hello world")
   return 1; //或者 1；
}

在Groovy中，很多东西都是可以省略的

语句后面的分号是可以省略的
变量的类型和方法的返回值也是可以省略的
方法调用时，括号也是可以省略的
甚至语句中的return都是可以省略的

task test() {
   method(1,2)
   method 1,2
}

def method(int a,int b){
    println a + b
}

return 可以不写
Groovy 会把方法执行过程中的最后一句代码作为返回值。但是方法调用时,括号不可以省略

task test() {
  println method(1,2)
}

def method(int a,int b){
    return a + b
}

//省略参数类型
def method(a,b){
    return a + b
}

// 方法省略参数类型
int method(msg) {
   println msg
   return 1 // 这个return不能省略
   println "done"
}

总结

在Groovy中，类型是弱化的，所有的类型都可以动态推断，但是Groovy仍然是强类型的语言，类型不匹配仍然会报错；
在Groovy中很多东西都可以省略，所以寻找一种自己喜欢的写法；
Groovy中的注释和Java中相同。

String

task test() {
   def a = 10086
   def b = "hello"
   def c = "a=${a}, b=${b}"
   println c
}
output：a=10086, b=hello

集合

Groovy加强了Java中的集合类，比如List、Map、Set等。

List

task test() {
    def testList = [1,2,3,4,5,6]
	println testList[0]
    println testList[-2]
    println testList[0..3]
    testList.each{
       println it
    }
}

List还有一种看起来很奇怪的操作符<< (leftShift(Object value)) 左移位表示向List中添加新元素的意思

	testList << 200
	println testList.size

Map

task test() {
     def map1 = ['id':1010,'name':"xiaoming",'age':'26']
     println map1.getClass().name
     println map1['id']
	 map1['id'] = 1111
	 println map1['id']
     println map1.name
     println map1['age']

     map1.each{
          println "Key:${it.key},Value:${it.value}"
     }
}

闭包

Groovy中，闭包作为一种特殊的数据类型而存在，闭包可以作为方法的参数和返回值，也可以作为一个变量而存在。比如集合的 each 方法，参数其实就是一个闭包
闭包定义的格式：

//方式1：定义参数
{闭包参数,闭包参数,闭包参数...->闭包体}

//方式2：无定义参数，${it] 为默认的参数
{闭包体}

task demo() {
	 
     def test = { int a, String b ->
        println "a=${a}, b=${b}, Luck!!!"
     }
 
     // 这里省略了闭包的参数类型
     def test1 = { a, b ->
     println "a=${a}, b=${b}, Luck!!!"
    }

	 def test2 = { a, b ->
          a + b
    }
	
     test(10086, "Luck!!!")
	 test1.call(100, 200) 
     def c = test2(100,200)
     println c

}

闭包参数可接受可变类型

     //可变参数
    def concat = { int... params ->
        params.join()
    }
    println concat.call(1,2,3,4)//1234

闭包有一个参数时默认为it，当有多个参数时，it就不能表示需要将参数一一列出

// 这里省略了闭包的参数类型
def test3 = {
   println "num is ${it}"
}
test3(100)

Groovy API 文档
http://www.groovy-lang.org/api.html

在 Groovy 中调用闭包有两种方式

closuer.call(参数)
closuer()

with当对同一个对象进行操作时，可以使用with

task demo() {
	 
    Student st = new Student()
	st.with{
	   age = 18
	   sex = "男"
	   name = "张三"
	}
	
	println(st.name)
}

class Student{
    int age
	String sex
	String name
}

######判断是否为真

	def str = st.name
	//if (str != null && str.length() > 0){
	//   println(str)
	//}
	
	//上面的可以改写为
	if (str){
	    println(str)
    }

三元表达式

在Groovy中，三元表达式可以更加简洁，和Kotlin中的“Elvis 操作符”一样的 ?：

	def str = st.name
	str = str ?: "Unknown" //为空则返回 '：'右边的数据
	println(str)

简洁的非空判断

在Groovy中非空判断和可以用？表示

	if (st != null){
	    println(st.sex)
	}
	//可以简写成
	println(st?.sex)

==和equals

在Groovy中，==相当于Java的equals，，如果需要比较两个对象是否是同一个，需要使用.is()。

读取文件

task demo() {
	 	
	def file = new File("aa.txt")
	file.eachLine{ line -> println "${line}"}
	
	println("................")
	
	file.eachLine { 
	      line, lineNo ->
          println "${lineNo} ${line}"
    }
	
}

output:
孤独是冬夜下的雨
孤独是清晨的叹息
孤独是一首歌的名字
................
1 孤独是冬夜下的雨
2 孤独是清晨的叹息
3 孤独是一首歌的名字

访问xml文件 XmlParser和XmlSlurper

    def xml = new XmlParser().parse(new File("aa.xml"))
	
    // 访问declare-styleable节点的name属性
    println xml['declare-styleable'][email protected][0]
 
    // 访问declare-styleable的第三个子节点的内容
    println xml['declare-styleable'].attr[2].text()