Groovy

Groovy 是一种运行在 Java 虚拟机（JVM）上的动态语言，它以其简洁的语法和强大的功能而受到开发者的青睐。作为一种能够与 Java 无缝交互的语言，Groovy 继承了 Java 的许多优点，并且在某些方面进行了扩展和改进，使得开发者能够更加高效地编写代码。：Groovy 的设计哲学之一是减少模板化的代码和重复的模式，使得代码更加简洁。与 Java 相比，完成相同功能的 Groovy 代

一切总会归于平淡

1726人浏览 · 2024-04-05 18:20:36

一切总会归于平淡 · 2024-04-05 18:20:36 发布

1、简介

Groovy 是一种运行在 Java 虚拟机（JVM）上的动态语言，它以其简洁的语法和强大的功能而受到开发者的青睐。作为一种能够与 Java 无缝交互的语言，Groovy 继承了 Java 的许多优点，并且在某些方面进行了扩展和改进，使得开发者能够更加高效地编写代码。
以下是对Groovy特点的优化概述：

简洁性：Groovy 的设计哲学之一是减少模板化的代码和重复的模式，使得代码更加简洁。与 Java 相比，完成相同功能的 Groovy 代码通常更短，这使得代码更容易编写和维护。
动态类型：Groovy 支持动态类型，这意味着开发者无需显式声明变量类型。这种灵活性使得代码更加简洁，并且能够在编写代码时提供更快的反馈。
闭包和元编程：Groovy 引入了闭包和元编程的概念，这些特性使得代码更加灵活和强大。闭包允许开发者编写可重用的代码块，而元编程则允许在运行时动态地创建和修改类和方法。
函数式编程支持：Groovy 支持函数式编程范式，开发者可以编写更加简洁和表达性强的代码。在 Groovy 中，不需要显式的 main 函数，这使得编写脚本和快速原型开发变得更加容易。
默认导入包：Groovy 默认导入了许多常用的 Java 包，这减少了开发者在编写代码时需要导入的包的数量，进一步简化了代码编写过程。
公共作用域：在 Groovy 中，所有的类成员默认是公开的（public），这简化了访问控制的声明，同时也鼓励开发者采用更加开放的设计模式。
对象化基本类型：Groovy 将基本类型视为对象，这意味着可以直接在基本类型上调用方法。这种特性使得代码更加一致，并且能够利用对象的特性。
DSL 支持：Groovy 支持领域特定语言（DSL），这使得开发者能够创建和使用专门针对特定问题的简洁、易读的语法。DSL 可以显著提高代码的可读性和可维护性。

Groovy 是基于 Java 语言的，所以完全兼容 Java 语法,所以对于 java 程序员学习成本较低。

详细了解请参考: https://www.groovy-lang.org/documentation.html

2、安装[非必须]

下载地址: https://groovy.apache.org/download.html

我这里就直接下载整个 4.0.20 版本的了。

然后我们直接找个地方解压,并配置相关的环境变量就好了。

然后就可以使用 CMD 查询是否配置成功了。

3、创建项目

4、基本语法

在Groovy中，类型转换是一个非常自然和灵活的过程，它允许不同类型的数据在需要时自动转换。这种特性极大地简化了代码的编写和维护，因为它减少了显式类型转换的需求。以下是对Groovy中类型转换和类处理的详细说明：

类型转换

Groovy支持多种类型之间的自动转换，这包括：

字符串与基本类型之间的转换：Groovy允许将字符串转换为基本类型（如int、double等），反之亦然。例如，字符串"123"可以通过调用.toInteger()方法转换为整数。

基本类型与其包装类之间的转换：Groovy中的基本类型和它们的包装类（如Integer对应int）之间可以无缝转换。这意味着你可以在需要对象的地方使用基本类型，而在需要基本类型的地方使用包装类对象。

这种自动类型转换的特性使得Groovy在处理不同类型的数据时更加灵活和方便。开发者不需要编写额外的代码来进行显式的类型转换，从而可以专注于业务逻辑的实现。

类说明

在Groovy中，如果你创建了一个没有类定义的脚本文件，这个文件将被当作一个脚本（script）来处理。Groovy会自动将这个脚本转换为一个名为Script的类的实例，这个类的名字通常由文件名决定（去掉扩展名.goovy）。

在这个自动生成的Script类中，Groovy会创建一个run方法，这个方法包含了脚本的所有内容。这样，当你运行这个脚本时，实际上就是在调用这个run方法。

此外，为了便于外部执行，Groovy还会在这个自动生成的类中添加一个main方法。这个main方法会调用run方法，使得脚本可以在命令行或其他环境中作为程序执行。

这种将脚本转换为类的做法，使得Groovy脚本既可以作为独立的脚本运行，也可以作为类的一部分被导入和重用。这增加了Groovy的灵活性，并为开发者提供了更多的选择来组织和使用他们的代码。

4.1 案例 1: 创建

4.2 案例 2:基本注意点

提示:方法调用时,在不含有歧义的地方可以省略方法调用时的括号。这类似于使用${变量名}时，括号在不引起歧义的地方可以省略是一样的：如

4.3 案例3:引号说明

4.4 案例 4:三个语句结构

Groovy 支持顺序结构从上向下依次解析、分支结构(if…else、if…else if …else…、switch…case、for、while、do…while)

具体参考官网：http://www.groovy-lang.org/semantics.html#_conditional_structures

4.5 案例 5:类型及权限修饰符

Groovy 中的类型有:

1.原生数据类型及包装类

Primitive type	Wrapper class
boolean	Boolean
char	Character
short	Short
int	Integer
long	Long
float	Float
double	Double

2.类、内部类、抽象类、接口

3.注解

4.Trait: 可以看成是带有方法实现的接口

权限修饰符: public、protected、private

Groovy 类与 Java 类在设计和使用上有一些显著的区别，这些区别使得Groovy在某些方面更加灵活和简洁。以下是Groovy类与Java类之间的主要区别的进一步阐释：

可见性修饰符：在Java中，你需要使用public、protected、private或default关键字来指定类或方法的可见性。而在Groovy中，如果没有明确指定可见性修饰符，类或方法默认是公共的（public）。这减少了模板化的代码，使得代码更加简洁。对于包级别的私有可见性，可以通过@PackageScope注解来实现。

属性和getter/setter：在Java中，你需要为类中的每个字段显式编写getter和setter方法，除非你使用了自动getter和setter的语法（Java 11及以上版本）。而在Groovy中，如果没有为字段指定可见性修饰符，字段将自动转换为属性，并且Groovy会自动生成相应的getter和setter方法。这进一步简化了代码，使得开发者可以专注于业务逻辑的实现。

final属性：在Groovy中，如果你声明了一个属性为final，Groovy不会为这个属性生成setter方法。这是因为final关键字表示该属性的值一旦被赋值后就不可更改，因此不需要setter方法。这与Java的行为是一致的，但在Groovy中，你不需要显式编写setter方法。

源文件与类的关系：在Java中，每个源文件通常只包含一个公共类，并且源文件的名称必须与公共类的名称相匹配。而在Groovy中，一个源文件可以包含一个或多个类，但如果源文件中没有类定义的代码，则将其视为脚本。脚本是一种特殊的类，它们的名称与源文件名相同，并且脚本中定义的所有代码都被包含在run方法中。如果你在脚本文件中定义了与文件名相同的类，那么这个类将被视为脚本的扩展，并且可以通过Script类来访问。

这些区别使得Groovy在编写脚本和快速原型开发时更加高效和方便。Groovy的这些特性不仅简化了代码，还提高了开发效率，使得开发者可以更加专注于业务逻辑的实现，而不是被繁琐的语法和模板化代码所困扰。

提示 : 有关 Groovy 中各种各样的数据类型和权限修饰符及 Goovy 与 Java 区别请参考：

http://www.groovy-lang.org/objectorientation.html#_modifiers_on_a_property

4.6 案例 6:集合操作

操作	List	Map
添加元素	add()	put()
添加集合	plus()
删除指定下标元素	remove()
删除指定元素	removeElement()	remove()
移除集合中的元素	removeAll()
弹出最后一个元素	pop()
修改指定下标元素	putAt()
遍历	each()	each()
获取元素个数	size()
判断是否包含值	contains()
集合加减操作	不支持	+、-

请参考官网:http://www.groovy-lang.org/syntax.html#_number_type_suffixes

提示:可以把不同的基本类型添加到同一集合中。

4.7 案例 7:类导入

Groovy 语言默认提供的导入

import java.lang.*
import java.util.*
import java.io.*
import java.net.*
import groovy.lang.*
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal

这样做是因为这些包中的类最常用。通过导入这些样板代码减少了。

参考官网地址：http://www.groovy-lang.org/structure.html#_imports

4.8 案例 8:异常处理

Groovy 中的异常处理和 java 中的异常处理是一样的。

参考官网地址： http://www.groovy-lang.org/semantics.html#_try_catch_finally

4.9 案例 9:闭包

闭包是Groovy语言中一个非常强大和灵活的特性，它允许开发者以一种简洁和表达性强的方式来编写代码。闭包的概念源自函数式编程，它提供了一种定义代码块的方式，这个代码块可以被赋值给变量、作为参数传递给方法或者在类中定义为成员。

闭包的特性

开放和匿名：闭包不需要显式的类型声明或名称，它可以在任何地方被定义，并且可以被赋值给变量或者作为参数传递。这种开放和匿名的特性使得闭包非常灵活和方便。
接受参数和返回值：闭包可以定义自己的参数，就像方法一样。同时，闭包也可以有返回值。这使得闭包可以执行复杂的操作，并且可以返回结果。
引用外部变量：闭包可以捕获并使用其定义时所在的作用域中的变量。这意味着闭包可以访问定义它的上下文中的局部变量，甚至是在闭包被调用时那些变量可能已经不存在了。

闭包的语法

闭包的基本语法如下：

{ [closureParameters -> ] statements }

closureParameters：这是闭包的参数列表，它是一个逗号分隔的列表，可以包含类型化的或非类型化的参数。如果闭包不接受参数，这部分可以省略。
->：这个箭头字符用来分隔参数列表和闭包体。
statements：这是闭包的主体，包含了一系列的Groovy语句，这些语句定义了闭包要执行的操作。

闭包的使用

闭包可以在多种场合使用，例如：

作为变量的值：

// 定义一个闭包myClosure，它接收一个参数it，返回参数的两倍
def myClosure = { it * 2 }

// 使用闭包myClosure，传入参数5，检查结果是否等于10
def result = myClosure(5) == 10

// 打印结果
println(result)

作为方法的参数：

/**
 * 遍历一个数字列表并打印每个数字。
 *
 * @param numbers 一个包含整数的列表。
 *
 * 本示例中没有返回值，因为它只是简单地遍历并打印列表中的每个元素。
 */
def numbers = [1, 2, 3, 4, 5]
// 使用each方法遍历numbers列表，对每个元素执行.println操作进行打印
numbers.each { println it }

在类中定义为成员：

class MyMath {
    /**
     * 将输入参数乘以二。
     *
     * @param it 输入的数字。
     * @return 输入数字的两倍。
     */
    def multiplyByTwo = { it * 2 }
}

// 创建一个 MyMath 的实例
def math = new MyMath()

// 验证 multiplyByTwo 方法是否正确工作
assert math.multiplyByTwo(5) == 10