当前位置: 萬仟网 > IT编程>移动开发>Android > Groovy语法基础

Groovy语法基础

2019年08月19日 17:52  | 萬仟网IT编程  | 我要评论

先来一张思维导图

groovy 简介

groovy 是一种基于 jvm 的动态语言,他的语法和 java 相似,最终也是要编译 .class 在jvm上运行。

groovy 完全兼容 java 并且在此基础上添加了很多动态类型和灵活的特性,比如支持闭包,支持dsl,是一门非常灵活的动态脚本语言。

这篇文章是为了能看懂在 gradle脚本中的代码,知道怎么写。所以不会深入groovy。

每个 build 脚本配置文件都是一个 groovy脚本文件。在里面可以写任何符合 groovy 语法的代码。
例如定义类,方法,变量等。又因为groovy 是完全兼容java的,故也可以写任何java代码,是完全兼容的。

dsl

dsl(domain specific language) 中文意思是 领域特定语言,专门关注某一领域,在于专而不是全。所以才是领域特定的。

gradle 的脚本就是基于 groovy 的dsl,专门解决自动化构建的dsl。
我们只需要按照相应的语法,配置相应的 gradle 脚本就可以达到自动化构建的目的,这也是 dsl 的初衷。

注释

单行注释

//这里是注释
def name = "佛系编码"

多行注释

/* 这里是多行注释
   啦啦啦啦 */

doc 注释

/**
 * 这里是 doc 注释
 * 啦啦啦啦
 */

数据类型

java中的基本数据类型,对象它都支持;另外还有
闭包
加强的 list,map的集合
加强的file,stream等io类型

类型可以显式声明,也可以用 def 来声明,用 def 声明的类型groovy将会进行类型推断。

基本数据类型都是和java 中的一致,就不拿出来说了。下面说一下,对象,字符串,闭包等;

另外:groovy 中的分号是可以省略的;

字符串

使用单引号和双引号都可以定义一个字符串常量。

差别是 单引号只是单纯的字符串,不能使用表达式,运算,求值,正则等。

task character(){
  dolast{
      def name = '张三'
      def address ="北京市"
      def age = 19
      println "单引号双引号都是字符串 name is ${name}; age is $age ; address is ${address}"
      println '单引号里无法运算表达式例如 name is ${name}'
  }
}

执行 character

gradle character

得到结果如下

单引号双引号都是字符串 name is 张三; age is 19 ; address is 北京市
单引号里无法运算表达式例如 name is ${name}

双引号的字符串可以直接进行表达式计算,规则是一个美元符号紧跟一个花括号: ${expression} ,如果只有一个变量可以省略花括号。例如上面的 $age

集合

集合默认是 java.util.arraylist 类型的

def nums = [1,2,4,5,6]
println "nums is ${nums.getclass().getname()} size = ${nums.size()}"

输出结果为

nums is java.util.arraylist size = 5

也可以显式指定集合类型 使用 as 关键字;

def nums1 = [0,"23",4,5,62,false] as linkedlist
println "nums1 is ${nums1.getclass().getname()};size = ${nums1.size()}"

输出为

nums1 is java.util.linkedlist;size = 6

或者在前面显式指定类型

linkedlist otherlinked = [3, 4, 5]

访问元素

元素的访问是通过下标访问的

println "第三个元素是 ${nums1[2]},倒数第一个是 ${nums1[-1]};第一个和倒数第一个:${nums1[0,-1]}"
println "第二个到第四个:${nums1[1..3]}"

输出为:

第三个元素是 4,倒数第一个是 false;第一个和倒数第一个:[0, false]
第二个到第四个:[23, 4, 5]

遍历元素

使用 each 方法遍历集合 参数默认是 it

//遍历
nums1.each {
  print "$it, "
}

输出为:

0, 23, 4, 5, 62, false,

带有下标的遍历:使用 eachwithindex 方法

numlist.eachwithindex { int value ,int index->
    println "list[$index] = $value"
    }

数组

数组的定义要明确的指定数组类型

string [] strings = ["i","'","m","is","a","dog","."]
   println "\n 数组 :${strings.getclass().getname()}"
   strings.each{
       print "$it "
   }

   def multi = [5,7,5,8,54,87] as int[]

   println "\n使用 as 显式指定类型: ${multi.getclass().getname()}"
   multi.each{
       print "$it "
   }

输出是

数组 :[ljava.lang.string;
i ' m is a dog .
使用 as 显式指定类型: [i
5 7 5 8 54 87

添加元素

使用 list.add() 添加元素

numlist.add(-11)

使用 可以使用 << 操作符添加一个

numlist << 13

修改元素

numlist[0] = 0

不用担心下标越界;groovy就自动增加到所需的下标,中间的会设置为 null

def numlist = [0,1,2,3,4,5] as linkedlist

        numlist.each{
            print "$it "
        }

        println "\n 在 10位置添加一个 11"

        numlist[10] =11

        println "添加后的:"

        numlist.each{
            print "$it "
        }

输出为:

> task :collect1
0 1 2 3 4 5 
 在 10位置添加一个 11
添加后的:
0 1 2 3 4 5 null null null null 11 
build successful in 0s

删除元素

使用 list.remove() 移除元素 参数可以是 下标,可以是值

numlist.remove 0
numlist.remove((object)10)

使用 list.removelast() 移除最后一个元素

numlist.removelast()

查找元素

使用 list.find() 查找第一个符合条件的元素

print "\n list.find() 查找第一个符合条件的元素 numlist.find { it%2==0}"
print numlist.find { it%2==0}

使用 list.findall() 查找所有符合条件的元素

print "\n list.findall() 查找所有符合条件的元素 numlist.findall {it % 2 ==0 }"
print numlist.findall { it % 2 ==0}

使用 list.any() 查找元素,只要有一个元素符合就返回 true

print "\n list.any() 只要有一个元素符合条件就返回 true numlist.any { it % 2 ==1} "
print numlist.any { it % 2 ==1}

使用 list.every() 查找元素,必须所有元素都符合条件才会返回 true

print "\n list.every() 必须所有元素都符合条件才会返回 true numlist.every {it % 2 == 0} "
print numlist.every { it % 2 == 0}

统计元素

统计符合条件的元素个数:使用 list.count()

print numlist.count { it % 2 ==0 }

统计最大值:list.max(),最小值:list.min()

print "\n 最大值是 ${numlist.max()} ,最小值是 ${numlist.min()}, 最小的绝对值是 "
print numlist.min { math.abs it}

map

map 的定义是键值对的方式,使用逗号隔开

def colors = [red:'#ff0000',green:'#00ff00',blue:'#0000ff']

访问 map 中的元素有三种方式:

  • map.key
  • map[key]
  • map.get(key)

例如:

task map{
    dolast{
        def colors = [red:'#ff0000',green:'#00ff00',blue:'#0000ff']
        println " map calss is ${colors.getclass().getname()}"
        println "通过 map.key 的方式访问 colors.red = ${colors.red}"
        println "通过 map[key] 的方式访问 colors['red'] = ${colors['red']}"
        println "通过 map.get(key) 的方式访问 colors.get(red) = ${colors.get('red')}"
    }
}

输出为 :

> task :map
 map calss is java.util.linkedhashmap
通过 map.key 的方式访问 colors.red = #ff0000
通过 map[key] 的方式访问 colors['red'] = #ff0000
通过 map.get(key) 的方式访问 colors.get(red) = #ff0000


build successful in 0s
1 actionable task: 1 executed

添加元素

//添加元素
colors['pink'] = '#ff00ff'
colors.yellow = '#ffff00'

修改元素

//修改元素
colors.red = 'red'
colors['blue'] = 'blue'
println "修改后的元素是 colors.red = ${colors.red},colors.blue = ${colors.blue}"

删除元素

//删除元素
colors.remove('red')

遍历元素

和上面的一样 使用 each 方法

//遍历 
colors.each{
    println "${it.key} :${it.value}"
}

查找元素

查找的方法 和 上面的都一样,只是 参数换成了 map.entry 或者 key,value ;
这里只用 find 做一个示例:

find 方法

def green = colors.find { key ,value ->
  if(key.equals('green')) {
      return colors[key]
  }
  return null
}

println "查找结果是 ${green}"


def blue = colors.find { map.entry entry ->
    if(entry.key.equals('blue')){
        return entry.value
    }
    return null
}
println "查找的结果是 ${blue}"

方法

方法也是使用 def 定义的

/*
 * 返回大的那个
 */
def max(int a ,int b){
    if(a>b){
      return   a
    }else{
      return   b
    }
}

return 是可以省略的

groovy 会把执行过程中的最后一句代码作为返回值

/*
 * 返回大的那个
 */
def max(int a ,int b){
    if(a>b){
         a
    }else{
       b
    }
}

括号是可以省略的;

在调用方法时括号是可以省略的;使用 空格间隔开参数即可

def printmaximum(int a,int b){
    if(a>b){
        println "the maximum value of $a and $b is $a"
    }else{
        println "the maximum value of $a and $b is $b"
    }
}

task method {
    dolast{
        println "max is ${max(0,1)}"
        printmaximum 10,20
    }
}

输出是

> task :method
max is 1
the maximum value of 10 and 20 is 20

build successful in 0s
1 actionable task: 1 executed

代码块是可以作为参数传递的

代码块就是一段被花括号包围的代码,其实就是闭包;

例如 each 方法

最原始的应该是这样的

colors.each({println it})

格式化后

colors.each({
    println it
})

groovy 规定最后一个参数是闭包,可以将闭包放在方法外面

colors.each(){
    println it
}

调用时方法的括号是可以省略的 就成了这样

colors.each {
    println it
}

闭包

闭包是 groovy 的一个重要特性,可以说是 dsl 的基础。

闭包其实就是一段匿名代码块。

闭包在 groovy 中是 groovy.lang.closure 类的实例,这使得闭包可以赋值给变量或字段。

定义一个闭包

def hello = { println "hello 佛系编码" }

调用这个闭包

hello.call()

另一种调用方式 直接在后面跟上 ()

hello()

下面模拟一个 each 的执行,定一个方法迭代集合中的元素

/*
  * closure 就是 闭包参数
  */
def customeach(closure){
    //迭代元素
    for(int i in 1..10){
    //在闭包后跟上 () 就是调用了 括号里的参数就是闭包要接收的参数
        closure(i)
    }
}

调用这个方法,传入一个闭包打印元素; 如果闭包只有一个参数,那么默认就是 it

// 如果只有一个参数 默认就是 it
customeach {
     println it
}

如果闭包要接收多个参数,那就必须把参数显式的列出来,使用 -> 将参数和主体分开

再次模拟一个 map 的 迭代:

def eachmap(closure){
    def map1 = [name:'佛系编码',age:666]
    map1.each {
        closure(it.key,it.value)
    }
}
·····

//如果有多个参数,就必须要把参数列出来,使用 -> 将 参数和主体分开
eachmap { key,value ->
    println "$key:$value"
}

闭包委托

groovy 闭包的强大之处在于它支持闭包方法的委托。

groovy 的闭包有三个重要属性

  • thisobject 闭包定义所在的类
  • owner 表示闭包定义所在的对象或闭包(闭包内还是可以定义闭包的),这个是最近原则,下面会做说明
  • delegate 默认和 owner 一致,可以手动修改。

如果将闭包定义在一个类中,默认三个属性都是相等的;

举个例子: 在 person 类中 定义了 一个 act 闭包

class person{
    private string name

    public int getage(){
       12
    }

    closure act ={
         println "thisobject:${thisobject.getclass()}"
        println "owner:${owner.getclass()}"
        println "delegate:${delegate.getclass()}"
    }
}

调用这个闭包,将会有下面的输出

> task :test
thisobject:class person
owner:class person
delegate:class person

build successful in 0s
1 actionable task: 1 executed

如果将 闭包定义在一个 闭包里,那么 thisojbect 就和 其他两个不一样,因为 thisobject 是表示的定义闭包所在的类,而 owner 表示 类或闭包

这次在 一个闭包里再定一个闭包看一下

class person{
    private string name

    public int getage(){
       12
    }

    closure act ={
        println "thisobject:$thisobject"
        println "owner:$owner"
        println "delegate:$delegate"
    }

    closure eat = {
        def test = {
            println "thisobject:${thisobject.getclass()}"
            println "owner:${owner.getclass()}"
            println "delegate:${delegate.getclass()}"
        }
        test()
    }
}

执行这个 eat 闭包,将会得到以下结果

> task :test
thisobject:class person
owner:class person$_closure2
delegate:class person$_closure2

build successful in 0s
1 actionable task: 1 executed

可以看到 thisobject 和 owner 已经不一样了,因为 thisobject 表示的是 所在的类,而 owner 表示的定义所在的类或闭包(最近原则)

三个属性已经很明白了吧,

委托策略

无论什么时候在闭包中访问某属性或调用某方法时,若没有明确的设置对象,那么就会调用一个委托策略。通过这个委托策略来决定如果访问属性或调用方法。

有以下几个策略,可以通过 闭包的属性更改:resolvestrategy

下面通过一个嵌套类演示一下 策略更改的实际应用。

定义两个类 person 和 内部类 foot ,并且两者都有 name 属性。person 多一个 age 属性。

class person{
    private string name

    public int getage(){
       12
    }

    class foot {
      string name
      closure walk = { it ->
          println "name is $name,age is $age ,delegate is ${delegate.getclass()}"
          //设置 delegate 属性
          delegate = it;
          resolvestrategy = closure.delegate_first
          println "修改策略为 closure.delegate_first delegate 优先"
          println "name is $name, age is $age ,delegate is ${delegate.getclass()}"

      }
    }

    void walk(){
        foot foot = new foot(name:'脚');
        foot.walk(this)
    }
}

调用 person 的 walk 方法

person person = new person()
person.name ="佛系编码"
person.walk()

将会得到下面的输出

> task :test
name is 脚,age is 12 ,delegate is class person$foot
修改策略为 closure.delegate_first delegate 优先
name is 佛系编码, age is 12 ,delegate is class person

build successful in 0s
1 actionable task: 1 executed

我来解释一下这个输出

第一个name 是 脚 ;这是因为默认策略是 closure.owner_first 是在 owner 寻找属性的;owner 当然是 foot了。

第二个 name 是 佛系编码;这是因为 策略改为了 clousre.delegate_first 是优先在 delegate 上寻找的,而又把 delegate 属性修改为了传进去的 person 实例,他的值在上面已经明确声明为了 佛系编码 。

而 age 只有在 person 中声明了 getage() 方法,明确返回了 12.所以即使更改了策略,换了delegate 的值,仍然是 12.

注:三个属性中 只有 delegate 属性可以修改。

在 gradle 中,我们一般会指定 delegate 为当前的 it,这样在闭包中就可以对 it 进行配置

定义一个 user 类

class user{

    string name
    int age
    
    def dumpuser(){

        println "name is $name,age is $age ."
    }

}

在构建配置脚本中定义一个方法,传入一个闭包参数用来配置 user 类

将闭包委托策略更改,并设置 delegate 属性

def user(closure<user> closure){
    user user = new user()
    closure.delegate = user
    closure.resolvestrategy = closure.delegate_first
    closure(user)
}

在使用的时候就是这样的了,gradle 中就有很多这种的 dsl 配置,例如我们创建的 task

task configclosure(){
    dolast{
      user {
        name = '佛系编码'
        age = 0
        dumpuser()
      }
    }
}

输出为

> task :configclosure
name is 佛系编码,age is 0 .

build successful in 0s
1 actionable task: 1 executed

闭包 api 传送门

这里只介绍和 java 中不同的地方.

先看段代码:

task obj{
    dolast{
        person p = new person()
        println "没赋值前的 :${p.name}"
        p.name = '佛系编码'
        println "赋值后的 :${p.name}"

        println "age is ${p.age}"
    }
}

class person{
    private string name

    public int getage(){
       12
    }
}

执行 obj 任务的输出

task :obj
没赋值前的 :null
赋值后的 :佛系编码
age is 12

build successful in 0s
1 actionable task: 1 executed

在 person 类中并没有定义 name 属性的 get/set 方法;却可以设置和修改它的值;

这是因为 groovy 帮我们搞定了 get/set 方法。

age 属性也没有在 person 类中定义,只是定义了一个 getage() 方法却可以使用 age 属性。

但是,因为没有定义 set 方法,所以 age 属性只能访问。

运算符

这里只列出来和 java 不同且常用的运算符

可空运算符

对象非空时使用对象本身,对象为空时使用给定值;常用于给定某个可空变量的默认值。

task operator {
    dolast{
        person person = new person();
        //person.name 为 null 所以会使用 佛系编码
        def name = person.name ? person.name:'佛系编码'
        // getage 返回 12 不为空 所以使用本身
        def age = person.age ?:10
        println "name is $name , age is $age"
    }
}

输出

> task :operator
name is 佛系编码 , age is 12

build successful in 0s
1 actionable task: 1 executed

安全导航运算符

当调用一个对象上的属性或方法时,如果对象是空的,就会抛出空异常,这个使用 ?. 运算符,当对象为空时,表达式的值也是空,就不会抛出异常。

task operator {
    dolast{
        user user
        println "user.name is ${user?.name}"
    }
}

输出是

> task :operator
user.name is null

build successful in 0s
1 actionable task: 1 executed

断言

断言是用于验证假设条件是否为真,在groovy的断言中,如果假设的条件不为真,那么就会抛出java.lang.assertionerror异常。

groovy断言和java断言完全不同。groovy断言是一项语言功能,一直处于开启状态,和jvm的断言功能-ea完全无关。所以它是我们进行单元测试的首选方式。

例如

assert 1==2 :"1不等于2"

会抛出以下异常

failure: build failed with an exception.

······

* what went wrong:
execution failed for task ':operator'.
> 1不等于2. expression: (1 == 2)

当然不给出消息也是可以的

assert 1==2

那么异常就是这样的。

execution failed for task ':operator'.
> assert 1==2
          |
          false

在使用断言时最好是给出一条消息,此消息可以帮助其他人理解和维护你的代码,理清你的意图。

groovy api 查询方式

对于闭包的参数,只能在 api 查询了,没有什么好的办法。

这里把 groovy 文档地址列出来,方便大家查询相关 api

运行须知

要使用 gradle 或者 ./gradle 或者 gradlew 命令,必须是要安装gradle 并设置过环境变量的,当然在gradle所在的目录也是可以的。

build.gradle 是gradle 的默认构建脚本文件,在执行 gradle 命令的时候会默认找在当前目录下的 build.gradle 文件。

也可以通过 -b 参数指定加载执行的文件。

例如 要执行 groovu-basic.build 里的 operator 任务

gradle -b groovy-basic.gradle operator

如果要执行上面的测试代码,步骤是

  1. 新建一个 build.grale 文件 或者是通过 gradle 新建一个项目 看这篇
  2. 定义一个任务,添加动作
task test{
    dolast{
        //这里是代码
    }
}
  1. 粘贴代码
  2. 运行任务
gradle test

附上我的 gradle 版本

版本

如对本文有疑问,请在下面进行留言讨论,广大热心网友会与你互动!! 点击进行留言回复

相关文章:

◎已有 0 人评论

Copyright © 2019  萬仟网 保留所有权利. 粤ICP备17035492号-1
站长QQ:2386932994 | 联系邮箱:2386932994@qq.com