Groovy系列一 Groovy基础语法

待我称王封你为后i 2024-03-16 09:58 109阅读 0赞

**目录**

为什么要学习Groovy

Groovy 介绍

Groovy 特点

Groovy 实战

动态类型

简单明了的list,map类型

在groovy世界任何东西都是对象

属性操作变得更容易

GString

闭包

委派：delegate

Switch变得更简洁

元编程

强制类型检查

Elvis Operator

安全访问

--------------------

## 为什么要学习Groovy ##

作为Java为主语言的程序员，Groovy作为Java平台上的脚本语言（动态语言）在兼容方面是有得天独厚的优势。接触过Aandroid开发的同学大家都已经接触到啦Gradle构建项目（Gradle构建也支持Java项目的构建），Gradle就是采用Groovy实现的用于构建项目的框架。还有就是新版本的idea推荐使用Gradle进行插件开发。当然以上只是从客观方面阐述Groovy技术的发展趋势（包含但不仅限于这些方面）来说明我们需要学习，从自身层面来说多学多益，或者说有技术追求或者技术理想的同学，多学一门技术也是对自己的提升。接下来就让我们一起走进Groovy的世界吧。

## Groovy 介绍 ##

![b48c053883684f3e860079f1700b98bf.png][]

> Apache Groovy是一种强大的、可选的类型和动态语言，具有静态类型和静态编译功能，用于Java平台，旨在通过简洁、熟悉和易于学习的语法提高开发人员的生产力。它可以与任何Java程序顺利集成，并立即为您的应用程序提供强大的功能，包括脚本功能、领域特定语言创作、运行时和编译时元编程以及函数式编程。
> 
> \-- groovy 官网

以上是官网介绍，我个人的通俗理解如下，Groovy是用于Java虚拟机的一种敏捷的动态语言，是一种成熟的面向对象编程语言，又是一种纯粹的脚本语言。Groovy运行在JVM环境上，在语法上兼具java 语言和脚本语言特点，大大简化了语法。同时又具有闭包和动态语言中的其他特性，弥补了单纯的Java代码所不具备的动态性，我们可以在程序运行时任意修改代码逻辑，不需要重新发布。

Groovy 1.0于2007年1月2日发布。 Groovy通过Apache License v 2.0发布。Groovy的官方网站是[The Apache Groovy programming language][]

## Groovy 特点 ##

Groovy中有以下特点（官网API文档：[The Apache Groovy programming language - Groovy Development Kit][]）：

1.  Groovy是基于Java虚拟机的一种面向对象的脚本语言，同时支持静态和动态类型。
2.  Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似，可以使用现有的Java库。
3.  支持运算符重载。
4.  本地语法列表和关联数组。
5.  对正则表达式的本地支持。
6.  各种标记语言，如XML和HTML原生支持。
7.  Groovy扩展了java.lang.Object。

## Groovy 实战 ##

### 动态类型 ###

groovy的第一个特性就是动态特性，定义一个变量以后，可以对这个变量赋与任何类型的值；groovy提供了这种支持方式但是出于好的编码习惯而言，我们是杜绝这种开发方式的。

def v = 0;//定义了数值类型的变量v 
    v = new Date();//然后又给它赋与Date类型的值. 
    println(v);

### 简单明了的list,map类型 ###

我们可以使用groovy简单明了的定义list和map数据结构。不像在Java中国我们要先定义类型才能赋值，Groovy直接使用语法糖就可以快速赋值。具体看如下的代码事例，只列举了其中典型的API进行概念说明，剩余的API如果同学们感兴趣可以自行尝试练习。

*  使用"\[\]"定义list列表，并对其直接操作

// list 可以看到的是编译器帮我们作何类型识别
    def list = [1, 2]
    // 这个是groovy的list的API从左边插入一个记录
    list.leftShift(3)
    // push是从插入到列表前面
    list.push(0)
    // add和我们java的List一样是追加到最后
    list.add("abc")
    // groovy中的<<可以对list数据类型的作用添加值，也是追加到最后面，需要注意的是在数字类型时是位运算操作
    list << "<<号";
    // "+"在groovy的语法中也是追加元素到集合中，并且是追加到最后
    list += "加上+="
    
    // 查看打印结果可以看到我在每个API的功能描述上的说明
    // [0, 1, 2, 3, abc, <<号, 加上+=]
    println(list)
    
    // 也可以采用 lambda 表达式遍历集合
    list.forEach({ println(it)})

*  使用":"分隔key和value来定义map数据，key不需要用引号引起来，并且能使用key直接对map进行读写操作

def map = [a: 2, b: new Date()];
    
    // 写入 直接追加到map集合中
    map.put("aaaa","bbb")
    
    println(map)
    // 写入 直接采用Map的key进行操作
    map.a = "a value change"
    
    println(map)
    
    // 结果如下 可以看到 key 为 "a" 的value被改变
    [a:2, b:Sun May 28 11:19:56 CST 2023, aaaa:bbb]
    [a:a value change, b:Sun May 28 11:19:56 CST 2023, aaaa:bbb]

### 在groovy世界任何东西都是对象 ###

怎么理解上面的概念呢，对照着Java语言来说，我们都知道在Java语言中有是区分对待基本类型和引用类型的。基本类型是没有方法调用的因为基本类型是按值访问的，在这个方面Groovy比Java更像是一个面向对象语言。

// 在groovy中，一切都是对象。一切都可以当成对象来使用；
    // 即使在Java中的基本类型也更像是一个对象
    100.times {println("hello world")}

### 属性操作变得更容易 ###

不同于Java中要操作一个对象中的属性必须通过get,set方法，即使是将属性定义成private。在groovy中，定义一个javabean，不再需要写getter,setter方法。读写属性直接用"."号操作即可。

class JavaBeans {
        String a
        // 即使是定义成private 也可以直接访问
        //    private String a
    }
    
    def beans = new JavaBeans();
    
    beans.a = "object set property value"
    
    println(beans.a)

### GString ###

GString是Groovy提供的快速处理字符串的工具。双引号""号的下字符串，可以直接通过 $var 或者 $\{var\}方式简单明了的嵌入变量。并且GStrng会调用包含的闭包 无参GString会调用闭包并打印我们期待的结果到Writer。

// case1
    def a = "a"
    def b = "b"
    // a=a,b=b 快速替换字符串变量
    println("a=${a},b=$b")
    
    // case2
    def name = 'lly'
    def hello = "hello $name !"
    // 结果：hello lly ! 快速替换字符串变量
    println hello
    // 注意这一行
    name = '阳仔'
    // 结果：hello lly !
    println hello
    
    // case3　：GStrng会调用包含的闭包 无参GString会调用闭包并打印我们期待的结果到Writer
    def quote = "${-> name} , welcome"
    // 结果：阳仔 , welcome
    println quote
    // 注意这一行
    name = 'lisi'
    // 结果：lisi , welcome
    println quote

### 闭包 ###

在groovy中的闭包可以看成是一个代码块，它可以没有参数和返回值；它像java8以上的lambda语法或者像一个有一个方法的java内部类（这里类似于函数式编程规范定义）。在groovy闭包中的隐含内置变量，通过哪住的变量我们可以做一些获取单独元素操作的事情。比如迭代、判断等等其他业务。

> it：当闭包的方法中，没有定义任何参数时，也可以直接用it变量；
> 
> this：跟java中的this一样；
> 
> owner：基本上跟this一样，只是除了一种情况，如果该闭包是在其他的闭包中定义的，owner就指向定义它的闭包对象。

// 闭包中内置了很多迭代方法，如find、findAll、collect等等。这里需要注意的是内置对象 it 的使用
    def list = ['foo', 'bar']
    def newList = []
    list.collect(newList) {
        it.toUpperCase()
    }
    // 结果：[FOO, BAR]
    println newList
    
    //或者
    list = ['foo', 'bar']
    newList = []
    list.collect(newList, {
        it.toUpperCase()
    });
    // 结果：[FOO, BAR]
    println newList
    
    
    // 在groovy闭包中的隐含内置变量
    
    def a = {
        println "a this:" + this
        println "a owner:" + owner // ower指向b
    
        def b = {
            println "b this:" + this
            println "b owner:" + owner // ower指向b
        }
        b.call()
    
    }
    a.call()
    
    // 结果：这里可以看到 this 和 owner 异同
    a this:script.GroovyDemo1@78b236a0
    a owner:script.GroovyDemo1@78b236a0
    b this:script.GroovyDemo1@78b236a0
    b owner:script.GroovyDemo1$_run_closure3@304b9f1a

### 委派：delegate ###

Groovy中的delegate基本上是跟owner的一样，除非它通过Closure.setDelegate()委派指向新的对象。

def scriptClosure = {
        println "scriptClosure this:" + this
        println "scriptClosure owner:" + owner
        println "scriptClosure delegate:" + delegate
    }
    println "before setDelegate()"
    scriptClosure.call()
    scriptClosure.setDelegate("lly")
    println "after setDelegate()"
    scriptClosure.call()
    
    // 结果：
    scriptClosure this:script.GroovyDemo1@5c371e13
    scriptClosure owner:script.GroovyDemo1@5c371e13
    scriptClosure delegate:script.GroovyDemo1@5c371e13
    after setDelegate()
    scriptClosure this:script.GroovyDemo1@5c371e13
    scriptClosure owner:script.GroovyDemo1@5c371e13
    scriptClosure delegate:lly

### Switch变得更简洁 ###

Groovy中的switch可以允许专入list,对象，范围...等表达式作为case依据

def x = 20;
    switch (x) {
        case [1, 2, 3, 4, 5]:
            println("aaaaaa")
            break;
        case "foo":
            println("bbbbb")
        case 10..1000:
            println("ccccc")
            break;
        case Date:
            println("dddddd")
            break;
    }
    
    // 结果： 因为 20 在 10到1000 的范围内
    ccccc

### 元编程 ###

在Groovy中，可以使用 metaClass类来，对元对象添加属性和方法。原因是由于在Groovy中，如果你的对象使用了一个它不曾定义过的方法不会报错，至少编译的时候不会报错，这就是因为Groovy特殊的运行时机制。你调用了一个对象的方法，他会先去检查这个类里面是否定义了这个属性和方法。如果没有的话会去MeteClass中去寻找，在Java中所有的类都会集成Object，而在Groovy中，所有的类都会继承GroovyObject，这个类里面就有获取MeteClass的方法。这样，就可以在运行中去动态的给对象添加属性和方法，甚至是静态的方法。如果MeteClass中也没有定义这个方法的话，就要去依次去寻找实体类里面是否实现了methodMissing和invokeMethod方法了，在这两个方法里面可以做特殊的处理。

// 基本元编程
    // 对String类，添加一个uppers方法
    String.metaClass.uppers = { -> toUpperCase() };
    println "aaa".uppers()
    //结果：AAA
    
    // 对Interger类，添加一个say方法
    Integer.metaClass.say = { -> "I am Interger" }
    def i = new Integer(100);
    println i.say()
    // 结果：I am Interger
    
    // 给对象添加属性、方法、静态方法
    class Person {
        String name;
        Integer age;
    
        String eat() {
            println(name + "like eat")
        }
    }
    def p = new Person(name: "阳仔", age: 18)
    p.eat()
    
    // 给对象添加属性
    p.metaClass.sex = '男'
    // 给对象添加方法
    p.metaClass.drink = {
        -> println "喜欢喝饮料"
    }
    // 给对象添加静态方法
    p.metaClass.static.play = {
        -> println "喜欢玩游戏"
    }
    
    println "${p.name}，今年${p.age}岁了，性別是${p.sex}"
    p.drink()
    p.play()
    
    // 结果
    阳仔like eat
    阳仔，今年18岁了，性別是男
    喜欢喝饮料
    喜欢玩游戏

### 强制类型检查 ###

在之前的咱们的学习过程中发现，Groovy都是弱类型检查，不管是变量还是集合都可以接收任何类型的数据，如果我们想要在某些场景中限制某种类型就要用到@TypeChecked注解尽兴强制类型检查。在闭包中，如果需要强类型检查，可以像java语法一样定义参数类型。

class Foos{
        int  i = 42.0; //编译通过
    }
    
    @TypeChecked
    class Foo{
        int  i = 42.0; //编译不通过
    }
    
    //在闭包中，如果需要强类型检查，可以像java语法一样定义参数类型
    def list = ["a","b","c"]
    // 编译不通过
    //def list = ["a","b","c", 1]
    list.collect {
        String it -> it.toUpperCase()
    }
    println(list)

### Elvis Operator ###

Groovy中采用Elvis Operator 运算，进一步简化三元运算符。

def a = null;
    // 在定义b变量时，先判断a是否有值，如果有，就取a的值作为b的值，否则就取值"b"
    def b = a ?: "b"; 
    println(b)

### 安全访问 ###

跟我们Java中判空一样，只不过更加简洁而已。

def person;
    //先判断person是否为不为null,然后，再调用getName方法
    String name = person?.getName();
    println(name)

[b48c053883684f3e860079f1700b98bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/3de713cf942d4ad98b108b1aafc0f0bb.png
[The Apache Groovy programming language]: http://www.groovy-lang.org/
[The Apache Groovy programming language - Groovy Development Kit]: http://www.groovy-lang.org/api.html