---

学Groovy有什么用？？？

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

1. 脚本编程：Groovy是一种非常适合编写脚本的语言。它具有简洁的语法和强大的表达能力，可以用于自动化任务、批处理脚本、快速原型开发等。

2. Java增强：Groovy可以无缝与Java代码进行集成。它与Java语法兼容，并提供了许多便利的语法糖和功能增强，使得编写Java应用程序变得更加简洁和高效。

3. 领域特定语言（DSL）：Groovy提供了创建和使用领域特定语言的能力。DSL是一种专门用于解决特定领域问题的语言，使用DSL可以提高代码的可读性和表达能力。Groovy的灵活语法使得创建DSL变得相对容易。

4. 脚本测试：Groovy提供了强大的测试支持。它具有丰富的测试框架和工具，可以帮助开发人员编写单元测试、集成测试和功能测试等。

5. Grails框架：Groovy是Grails框架的官方语言。Grails是一个基于Groovy的全栈Web应用程序开发框架，它简化了开发过程，提供了许多开箱即用的功能和插件，能够快速构建高性能的Web应用程序。

总的来说，学习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基本语法

1. 变量声明和数据类型
   在Groovy中，可以使用关键字def来声明变量，无需指定数据类型。例如：

def name = "Groovy"
def age = 30

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

2. 字符串操作
   Groovy提供了丰富的字符串操作功能。你可以使用单引号或双引号来定义字符串，并使用加号进行字符串拼接。例如：

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

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

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

3. 列表和映射
   Groovy提供了方便的列表和映射数据结构。列表使用中括号表示，元素之间用逗号分隔。例如：

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

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

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

4. 条件语句
   Groovy支持常见的条件语句，如if-else语句和switch语句。例如：

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

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

5. 循环语句
   Groovy提供了多种循环语句，如for循环和while循环。例如：

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

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

6. 方法定义
   在Groovy中，可以使用关键字def定义方法。例如：

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

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

三、更多特性和扩展

1. 闭包
   Groovy中的闭包是一种匿名函数，可以作为参数传递给其他方法或赋值给变量。闭包在Groovy中广泛应用于集合操作、事件处理等场景。例如：

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

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

2. 文件操作
   Groovy提供了方便的文件操作功能，使得读写文件变得简单。你可以使用File类进行文件的读取和写入，例如：

def file = new File("data.txt")// 读取文件
def content = file.text
println(content)// 写入文件
file.write("Hello, Groovy!")

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

3. 类和对象
   Groovy可以与Java类和对象无缝集成，同时也提供了一些便捷的语法糖。你可以使用class关键字定义类，使用new关键字创建对象。例如：

class Person {String nameint agevoid sayHello() {println("Hello, I'm $name.")}
}def person = new Person(name: "John", age: 30)
person.sayHello()

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

4. 数据库访问
   Groovy提供了方便的数据库访问功能，可以轻松地执行SQL查询和更新操作。你可以使用内置的Sql类或使用第三方库如GORM进行数据库操作。例如：

@Grab('org.codehaus.groovy.modules:groovy-sql:3.0.7')
import groovy.sql.Sqldef 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的增删改查操作：

1. 增加元素：

def map = [:] // 创建一个空的Map// 增加键值对
map['key1'] = 'value1'
map.key2 = 'value2'// 批量增加键值对
map.putAll([key3: 'value3', key4: 'value4'])println map // 输出整个Map

2. 删除元素：

def map = [key1: 'value1', key2: 'value2', key3: 'value3']// 删除指定键的值
map.remove('key1')// 批量删除多个键
map.keySet().removeAll(['key2', 'key3'])println map // 输出修改后的Map

3. 修改元素：

def map = [key1: 'value1', key2: 'value2', key3: 'value3']// 直接修改指定键的值
map['key1'] = 'new value1'// 使用replace方法替换键值对
map.replace('key2', 'new value2')println map // 输出修改后的Map

4. 查询元素：

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.Datedef now = new Date()
println now

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

导入整个包

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

import java.util.*def list = new ArrayList<String>()
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 = 0try {def result = dividend / divisorprintln "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的特性来编写简洁而功能强大的代码。