2021-01-01

Groovy介绍：

下载SDK：https://groovy.apache.org/download.html

配置环境变量即可：

GROOVY_HOME="/Users/gary/LocalApplication/groovy-3.0.7"
export PATH=$GROOVY_HOME/bin:$PATH

检查：

➜  ~ groovy -v
Groovy Version: 3.0.7 JVM: 1.8.0_144 Vendor: Oracle Corporation OS: Mac OS X  # 说明环境配置成功了

介绍：

什么是Groovy?
Groovy是基于Java虛拟机的一-种敏捷的动态语言，它是一-种成熟的中OP (面向对象)编
)程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该种语言不必
编写过多的代码，同时又具有闭包和动态语言中的其他特性。

与Java相比,Groovy的不同点或优势

1. Groowy完全兼容Java语法,而且可做脚本也可做类
2. 分号是可选的,一般不加分号,以换行作为结束
3. 类,方法，字段都是公共的,没有访问权限限制
4. 默认生成具名(名值对)参数构造器key:value
5. 字段不定义访问权限时,编译器自动给字段添加getter/setter 方法
6. 字段可使用点来获取,无访问权限的也可使用getter/setter来操作
7. 方法可省略return关键字,自动检索最后一行的结果作为返回值
8. 空值比较不会有NullPointerException异常抛出。

Groovy 高级特性

1. assert断言:可以用assert代替之前Java的断言语句
2. 可选类型: 可使用类JavaScript的弱类型，可使用def来表示任意类型
3. 方法调用:调用带参方法时可省略括号.
4. 字符串定义:字符串定义有三种方式，单引号，双引号,三个单引号
5. 集合API : 集合的定义和使用更加简单API和Java有所不同,但兼容Java API
6. 闭包: Groowy 的一大特性，跟方法类似的代码块可赋给-个变量也可以做为参数传递给-一个方法, 像普通方法一样调用.

Groovy与Java比较

1. 可省略分号

2. 可省略getter/setter

3. 无权限修饰符自动生成getter/setter

4. getter/setter方式操作字段

5. 点方式调用字段

6. 调用自动生成的gtter/setter方法

7. 空值比较不抛出空指针异常

8. 空值比较不抛出空指针异常

   package xy.thinklife
   
   //不用修饰符，默认使用public
   class Student {
       String name    //每行代码可以省略 分号  ；
       int age
       //如果不指定作用域，默认是public，编译器会自动生成get 和set方法
     
       private int grader  // 这种的就不会自动生成get 和 set 方法
   }
   

9. 可省略return

       private int grader  // 这种的就不会自动生成get 和 set 方法
       int getGrader() {
           return grader
       }
       int getGrader1() {
           grader  // 这种的也可以
       }
   

10. Groovy本身就有脚本语言的特性

    Main.groovy 文件
    
    package xy.thinklife
    
    /**
    
    class Main{
        static void main(String[] args) {
     System.out.println(stu.getName())
        }
    }
     */
    
    //可以不用写类，像Python一样，脚本的形式执行代码，因为Groovy本身就有脚本语言的特性
    
    Student stu=new Student()
    stu.setName("gary lu")
    
    System.out.println(stu.getName())
    println(stu.getName())  //  groovy 自带一些 println() 函数
    // 还可以使用点的方式来取值
    stu.name="du xiu chen"
    System.out.println(stu.name)
    
    
    // 默认带有具名的构造器
    Student stu2=new Student(name: "gary lu",age: 18)
    println(stu2.name)
    

11. 默认带有具名构造器

    // 默认带有具名的构造器
    Student stu2=new Student(   name: "gary lu",age: 18   )
    println(stu2.name)
    

基本语法定义

/**
 * Groovy 是一个弱类型语言，使用 def 生命变量
 */
def name ="gary"
age=18  // 变量设置可以不写定义关键字

/**
 * 调用带参数方法时候可以省略括号（没参数的方法还是需要的）
 *
 */
println("hello world")
println "hello world"

/**
 * Groovy 自带断言关键字，并且会报错。其实编译后，类似  assert() 方法
 */
assert age==1

字符串定义

/**
 * 字符串支持三种类型的，单引号是普通的字符串，双引号可以使用 ${age} 调用变量，
 * 类似Python的 f"{age}" ,三个引号当输出的时候会带上格式，比如换行之类的。
 */
age=19
println "Hi"
println "今年我：${age} 岁了"

集合定义

/**
 * List集合，使用 [ ] 来声明 （当然，因为是兼容Java语法的，所以也可以用Java的写法）
 * 其实这样生成的是 Java 的 ArrayList 集合
 */

def v_list=[]
def list=["apple","pear"]
list.add("banana") // 往 List 最后添加元素
list << "peach"  // 这种方法也可以  往 List 最后添加元素


/**
 *  Map 映射，使用 [key:value] 方式定义  (注意，这里不是 {} )
 *  其实这样生成的是 Java 的 LinkedHashMap 集合
 */
def map=[name: "gary",age: 18]
map.put("age",19)   // 使用put 方法来复制或创建新的元素
map.gender ="boy" // 使用 .key 的方式来复制或创建新的元素

闭包定义

/**
 * 闭包就是将一个代码块复制给一个变量，这个变量就是闭包类型的变量
 */
Closure aaa = {
    println("aaa")
}
def aaa1 = {
    println("aaa")
}


/**
 * 定义带参数的闭包
 */
def bbb = {
    bbb, ccc ->
        println("sdfsdfd:  ${bbb}     ${ccc}")
}


/**
 * 定义方法  接收一个  不带参数的闭包
 * @param closure  一个不带参数的闭包
 */
def methed1(Closure closure) {
    closure()
    //或者 使用 call() 方法也是一样的
    closure.call()
}

/**
 * 定义方法  接收一个  带参数的闭包
 * @param closure 带参数的闭包
 */
//其实这种是一个动态泛型，Groovy接收的是object类型  def methed2(Closure<Object> closure)
def methed2(closure) {
    closure ("aaa", 111)
    或者
    closure "aaa", 111
}

闭包是Groovy的被喜好指出

/**
 * 调用接收闭包的方法
 */
methed1(aaa)
methed2 bbb // 这种方式也可以，因为接收参数的方法可以 省略括号


//既然可以这样调用，那么就形成了一个情况，直接传闭包
methed1({
    println("hello")
})
// 敢不敢再牛X一点？ 敢~
methed1 {
    println("hello /wink ")
}

methed2{
    score,age->
        println "分数：${name}   年龄：${age}"
}

//也可以 明确参数变量类型 这样写
methed2{
    String score,Integer age->
        println "分数：${name}   年龄：${age}"
}

闭包的更多传参方式

Groovy规定，如果方法最后一个参数是闭包，可以放到方法外面

以集合的each方法为例，它接受的其实就是一个闭包：

task printString {
    def numlist = ['ni', 'shi', 'sui']
    //将代码块当做参数传递
    numlist.each({
        println it
    })

    //Groovy规定，如果方法最后一个参数是闭包，可以放到方法外面
    numlist.each() {
        println it
    }

    //然后方法可以省略，就变成了我们经常看到的样式
    numlist.each {
        println "正在执行闭包参数"
        println it
    }
}

使用IDEA 创建 Groovy项目

image

其他更多Groovy语法解释

集合：Groovy完全兼容Java的集合，并对其进行了拓展，常见的集合有 List、Set、Map、Queue。

List：在实际运行中，还可以看出Grovvy得到的实际是一个ArrayList的实例。

task printList {
    def numList = [1, 2, 3, 4, 5, 6]

    numList.each{
        println it
    }
    
    println numList[1] // Groovy的写法
    println numList.get(1) //兼容Java的写法
    println numList[-1] //访问倒数第一个
    println numList[-2] // 访问倒数第2个 ，结果为5
    println numList[1..3] //截取
}

Map

task printMap {
    def map1=['width':18,'height':45]
    println map1['width'] // 使用key值获取
    println map1.height //Groovy获取
    println map1.get("width") //兼容Java

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

除了each 还提供了 find、collect、findAll等便捷的方法。

方法

Java调用方法非常规范，需要使用invokeMethod(parm1,parm2)而Grovvy可以省略（）变成 invokeMethod parm1,parm2 这在定义DSL的时候非常有用，书写非常方便。

JavaBean

Groovy在使用JavaBean时，不需要为JavaBean定义get、set方法，可以直接访问（原因是因为解析器帮忙做了这些动作，所以如果要隐藏属性就得特殊定义了）

 task printString {
    Person person = new Person()
    person.name = "燕燕"
    person.age = 18
    
    println "名字是：${person.name}" //虽然是private方法，但是还会可以调用到
    println "年龄：${person.age}"
    println "男生：${person.sex}" //和Java一样的特性，有默认值
}

class Person {
    private String name
    def age // 这种写法说明可以Java和Groovy混编，没有影响
    public boolean sex
}

闭包委托

Groovy强大之处就是在于它支持闭包方法委托。