Groovy入门

学Groovy有什么用？？？

Groovy是一种基于Java平台的动态脚本语言，它结合了Java的强大功能和动态语言的灵活性。

总的来说，学习Groovy可以扩展你的编程能力，并提供一种更简洁、灵活和高效的方式来编写Java应用程序、脚本和领域特定语言。它广泛应用于各种场景，包括脚本编程、测试、Web开发等。

一、Groovy简介

在某种程度上，Groovy 可以被视为 Java 的一种脚本化改良版,Groovy 也是运行在JVM 上，它可以很好地与 Java 代码及其相关库进行交互操作。它是一种成熟的面向对象编程语言，既可以面向对象编程，又可以用作纯粹的脚本语言。大多数有效的 Java 代码也可以转快为有效的 Groovy 代码，Groovy和 Java 语言的主要区别是：完成同样的任务所需的Groovy 代码比 Java 代码更少。

其特点为：

• 功能强大，例如提供了动态类型转换、闭包和元编程支持
• 支持函数式编程，不需要main函数
• 默认导入常用的包
• 类不支持default作用域，且默认作用域为public
• Groovy中基本类型也是对象，可以直接调用对象的方法
• 支持DSL（Domain Specific Languages领域特定语言）和其它简洁的语法，让代码变得易于阅读和维护

二、Mac安装Groovy

1、使用homebrew安装或官网下载

Groovy官网

brew install groovy

2、配置环境变量

 nano ~/.bash_profile 

#Groovy
export GROOVY_HOME=/usr/local/opt/groovy/libexec
export PATH=$GROOVY_HOME/bin:$PATH

按control+x保存后按Y确定退出编辑

3、重新加载环境变量

source ~/.bash_profile

二、Groov基本语法

def name = "Groovy"
def age = 30

Groovy还支持常见的数据类型，如字符串、整数、浮点数、布尔值等。

def name = "John"
def greeting = "Hello, " + name + "!"

此外，Groovy还支持字符串模板，可以在字符串中直接引用变量。例如：

def name = "John"
def greeting = "Hello, $name!"

def numbers = [1, 2, 3, 4, 5]

映射使用大括号表示，键值对之间用冒号分隔。例如：

def person = [name: "John", age: 30, city: "New York"]

def age = 18
if (age >= 18) {
    println("成年人")
} else {
    println("未成年人")
}

def language = "Java"
switch (language) {
    case "Java":
        println("我喜欢Java")
        break
    case "Groovy":
        println("我喜欢Groovy")
        break
    default:
        println("其他语言")
}

def numbers = [1, 2, 3, 4, 5]
for (number in numbers) {
    println(number)
}

def count = 0
while (count < 5) {
    println(count)
    count++
}

def sayHello(name) {
    println("Hello, $name!")
}

方法可以有参数和返回值。

三、更多特性和扩展

def closure = { name ->
    println("Hello, $name!")
}

closure("John")

闭包还支持多行定义和参数默认值等特性，使其更加灵活和强大。

def file = new File("data.txt")

// 读取文件
def content = file.text
println(content)

// 写入文件
file.write("Hello, Groovy!")

Groovy还支持文件的遍历、复制、删除等操作，让文件处理变得更加高效。

class Person {
    String name
    int age

    void sayHello() {
        println("Hello, I'm $name.")
    }
}

def person = new Person(name: "John", age: 30)
person.sayHello()

Groovy还支持扩展方法、属性、注解等特性，使得类的定义更加灵活和易于扩展。

@Grab('org.codehaus.groovy.modules:groovy-sql:3.0.7')
import groovy.sql.Sql

def sql = Sql.newInstance("jdbc:mysql://localhost:3306/mydb", "username", "password", "com.mysql.jdbc.Driver")

def result = sql.firstRow("SELECT * FROM users WHERE id = 1")
println(result.name)

sql.execute("UPDATE users SET name = 'Alice' WHERE id = 1")

Groovy的数据库访问功能简化了与数据库的交互，提高了开发效率。

四、Groovy简单使用

• groovy中使用def定义属性、方法，def支持动态类型声明
• 单行注释：// 多行注释：/**
• gradle语句最后的；（分号）是可以省略的
• groovy可以为属性自动生成getter、setter方法
• 方法声明时：参数类型、返回值类型、return关键字可以省略，方法调用时，在不引起歧义的地方，可以省略（）
• 变量引用时：在不引起歧义的前提下{}也可以省略，在容易引起歧义的地方不能省略{}
• 对象属性赋值：
  方式1：对象.属性名=
  方式2：对象["属性名"]=
  方式3：对象.属性setter方法（）
  方式4：具名构造器的方式
• 读取属性值
  方式1：对象.属性名
  方式2：对象["属性名"]
  方式3：对象.属性getter方法（）

1、Groovy中的字符串及三大语句结构

2、Groovy类与Java类的之间的主要区别

• 没有可见性修饰符的类或方法自动是公共的（可以使用一个特殊的注释来实现包的私有可见性）
• 没有可见性修饰符的字段将自动转换为属性，不需要显式的getter和setter方法
• 如果属性声明为final，则不会生成setter
• 一个源文件可能包含一个或多个类（但是如果一个文件不包含类定义的代码，则将其视为脚本）脚本只是具有一些特殊约定的类，它们的名称与源文件相同（所以不要在脚本中包含与脚本源文件相同的类定义）

3、集合操作

Groovy支持List、Map集合操作，并且拓展了Java中的API具体参考如下方法：
List：

• add（）：添加某个元素
• plus（）：添加某个List集合
• remove（）：删除某个指定的元素
• removeALL（）：移除某个集合中的元素
• pop（）：弹出List集合中的最后一个元素
• putAt（）：修改指定下标的元素
• each（）：遍历
• size（）：获取List列表中元素的个数
• contatins（）：判断列表中是否包含指定的值，则返回true

Map：

• put（）：向map中添加元素
• remove（）：根据某个键做移除，或者移除某个键值对
• +、-：支持map集合的加减操作
• each（）：遍历map集合

当使用Groovy语言处理Map时，你可以使用多种方式进行增删改查操作。下面是一些示例代码，展示了如何在Groovy中进行Map的增删改查操作：

def map = [:] // 创建一个空的Map

// 增加键值对
map['key1'] = 'value1'
map.key2 = 'value2'

// 批量增加键值对
map.putAll([key3: 'value3', key4: 'value4'])

println map // 输出整个Map

def map = [key1: 'value1', key2: 'value2', key3: 'value3']

// 删除指定键的值
map.remove('key1')

// 批量删除多个键
map.keySet().removeAll(['key2', 'key3'])

println map // 输出修改后的Map

def map = [key1: 'value1', key2: 'value2', key3: 'value3']

// 直接修改指定键的值
map['key1'] = 'new value1'

// 使用replace方法替换键值对
map.replace('key2', 'new value2')

println map // 输出修改后的Map

def map = [key1: 'value1', key2: 'value2', key3: 'value3']

// 通过键获取值
def value1 = map['key1']
def value2 = map.get('key2')

println "Value 1: $value1"
println "Value 2: $value2"

// 遍历Map的键值对
map.each { key, value ->
    println "Key: $key, Value: $value"
}

// 判断键是否存在
def containsKey = map.containsKey('key1')
def containsValue = map.containsValue('value2')

println "Contains Key: $containsKey"
println "Contains Value: $containsValue"

这些示例展示了在Groovy中对Map进行增删改查操作的常见方法。你可以根据自己的需求和场景，使用这些方法来处理Map数据。

4、类导入（Importing Classes）

在Groovy中，我们可以通过类导入来引入其他类或库，以便在代码中使用它们。类导入使我们能够更方便地引用类名，而无需每次都使用完全限定的类名。

单个类导入

可以使用import关键字导入单个类。下面是一个示例：

import java.util.Date

def now = new Date()
println now

在上面的示例中，我们导入了java.util.Date类，并创建了一个Date对象。

导入整个包

如果我们想要导入一个包中的所有类，可以使用import关键字后面加上包名.*的方式。例如：

import java.util.*

def list = new ArrayList()
list.add("Groovy")
list.add("Java")
println list

在上面的示例中，我们导入了java.util包，并使用ArrayList类创建了一个列表对象。

静态导入

Groovy还支持静态导入，使我们能够直接使用类的静态成员，而无需使用类名进行限定。示例如下：

import static java.lang.Math.*

def pi = PI
def squareRoot = sqrt(16)

println "PI: $pi"
println "Square root of 16: $squareRoot"

在上面的示例中，我们静态导入了java.lang.Math类的静态成员PI和sqrt()，并直接使用了它们。

5、异常处理（Exception Handling）

在Groovy中，我们可以使用try-catch-finally块来捕获和处理异常。异常处理使我们能够在程序执行过程中处理潜在的错误和异常情况。

下面是一个异常处理的示例代码：

def dividend = 10
def divisor = 0

try {
    def result = dividend / divisor
    println "Result: $result"
} catch (ArithmeticException e) {
    println "Error: ${e.message}"
} finally {
    println "Finally block executed"
}

在上面的示例中，我们尝试将dividend除以divisor，但divisor的值为0，会引发ArithmeticException异常。我们使用try-catch块捕获并处理该异常，在catch块中打印错误消息。无论是否发生异常，finally块中的代码都会执行。

除了catch块外，我们还可以使用finally块来执行无论是否发生异常都需要执行的代码，例如清理资源。

Groovy还提供了其他更高级的异常处理技术，如throws声明和自定义异常类，但以上示例覆盖了异常处理的基础用法。

6、闭包

定义：是一个开放的、匿名的代码块，它可以接受参数、也可以有返回值。闭包可以引用其周围作用域中声明的变量
语法：{ [closureParameters -> ] statements}
调用：

• 第一步：将闭包赋值给一个变量
• 第二步：变量名（）、变量名.call()

Groovy是一门基于Java平台的动态语言，它支持闭包作为一种重要的语言特性。闭包是一种可以被传递和执行的代码块，它可以像变量一样被赋值、传递和调用。

基本闭包定义

在Groovy中，闭包使用花括号 {} 定义，并且可以带有参数和方法体。以下是一个基本的闭包定义示例：

def greeting = { name ->
    "Hello, $name!"
}

println greeting("Alice") // 输出：Hello, Alice!

在上面的示例中，我们定义了一个闭包 greeting，它接受一个参数 name，并返回一个包含问候语的字符串。通过调用闭包，并传递一个参数 "Alice"，我们可以得到输出结果 "Hello, Alice!"。

闭包作为参数

闭包可以像其他类型的变量一样被传递给方法或函数，并在需要时被调用。以下是一个将闭包作为参数的示例：

def calculate = { operation, a, b ->
    operation(a, b)
}

def add = { x, y -> x + y }
def multiply = { x, y -> x * y }

println calculate(add, 2, 3) // 输出：5
println calculate(multiply, 2, 3) // 输出：6

在上面的示例中，我们定义了一个 calculate 闭包，它接受三个参数：operation（代表另一个闭包）、a 和 b。通过调用 calculate 并传递一个操作闭包和两个参数，我们可以执行不同的计算操作，这里分别是加法和乘法。

闭包的简化语法

Groovy提供了一些简化语法来定义和使用闭包。

简化参数定义

当闭包只有一个参数时，可以省略参数的括号。以下是一个示例：

def square = { it * it } // 使用默认参数名 "it"

println square(5) // 输出：25

在上面的示例中，我们定义了一个闭包 square，它只有一个参数。由于只有一个参数，我们可以使用默认的参数名 it，并省略参数的括号。通过调用 square 并传递参数 5，我们可以得到输出结果 25。

简化方法调用

当闭包作为最后一个参数传递给方法时，可以将闭包放在方法调用的圆括号外部。以下是一个示例：

def numbers = [1, 2, 3, 4, 5]

numbers.each { println it }

在上面的示例中，我们使用 each 方法遍历列表 numbers。each 方法接受一个闭包作为参数，用于对列表中的每个元素执行操作。我们将闭包放在方法调用的圆括号外部，使代码更加简洁。

闭包的其他用途

闭包在Groovy中具有广泛的应用，除了上述示例中的基本用法外，还有其他用途，包括：

• 迭代和集合操作：闭包可以与集合操作方法（如 each、collect、findAll 等）一起使用，实现对集合元素的迭代和转换。
• 配置和扩展对象：闭包可以用于配置对象的属性和行为，以及动态地向对象添加新的方法。
• 回调函数：闭包可以作为回调函数，用于在特定事件发生时执行自定义的操作。

闭包是Groovy的一个强大特性，它提供了灵活和简洁的方式来处理代码块。通过理解和掌握闭包语法，你可以更好地利用Groovy的特性来编写简洁而功能强大的代码。