Groovy基础

wangkay88

于 2023-06-24 17:45:52 发布

阅读量421

点赞数

分类专栏： Gradle 文章标签： java 单元测试开发语言

本文链接：https://blog.csdn.net/qq_54351538/article/details/131329248

版权

Gradle 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

学Groovy有什么用？？？

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

脚本编程：Groovy是一种非常适合编写脚本的语言。它具有简洁的语法和强大的表达能力，可以用于自动化任务、批处理脚本、快速原型开发等。
Java增强：Groovy可以无缝与Java代码进行集成。它与Java语法兼容，并提供了许多便利的语法糖和功能增强，使得编写Java应用程序变得更加简洁和高效。
领域特定语言（DSL）：Groovy提供了创建和使用领域特定语言的能力。DSL是一种专门用于解决特定领域问题的语言，使用DSL可以提高代码的可读性和表达能力。Groovy的灵活语法使得创建DSL变得相对容易。
脚本测试：Groovy提供了强大的测试支持。它具有丰富的测试框架和工具，可以帮助开发人员编写单元测试、集成测试和功能测试等。
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基本语法

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

def name = "Groovy"
def age = 30

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

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

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

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

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

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

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

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

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

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

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("其他语言")
}

循环语句
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++
}

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

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

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

三、更多特性和扩展

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

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

closure("John")

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

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

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

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

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

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

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

class Person {
    String name
    int age

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

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

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

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

@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<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 = 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的特性来编写简洁而功能强大的代码。

wangkay88

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Groovy基础

在某种程度上，Groovy 可以被视为 Java 的一种脚本化改良版,Groovy 也是运行在JVM 上，它可以很好地与 Java 代码及其相关库进行交互操作。它是一种成熟的面向对象编程语言，既可以面向对象编程，又可以用作纯粹的脚本语言。大多数有效的 Java 代码也可以转快为有效的 Groovy 代码，Groovy和 Java 语言的主要区别是：完成同样的任务所需的Groovy 代码比 Java 代码更少。功能强大，例如提供了动态类型转换、闭包和元编程支持支持函数式编程，不需要main函数。
复制链接

扫一扫