Groovy动态语言

会逃跑的乌龟

于 2024-09-01 10:07:07 发布

阅读量984

点赞数 16

文章标签： jvm

本文链接：https://blog.csdn.net/lhl0306/article/details/141779260

版权

一、GROOVY简介

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

以计算一个列表中数字的总和为实例，分别使用Java和Groovy进行实现，代码如下：

/*Java代码
 */
import java.util.Arrays;
import java.util.List;

public class SumExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        System.out.println("Sum: " + sum);
    }
}

/*Groovy代码*/
def numbers = [1, 2, 3, 4, 5]
def sum = numbers.sum()
println "Sum: $sum"

Groovy是JVM的一个替代语言，使用方式基本与Java代码的方式相同，该语言特别适合与Spring的动态语言支持一起使用。

二、环境准备

1、安装JDK

Groovy是基于Java平台的语言，其运行环境中依赖JDK，因此首先需要安装JDK。由于安装JDK是开发者必备技能，因此，具体安装方法和步骤不进行阐述。

2、安装Groovy

2.1 安装Groovy

首先需要下载Groovy安装包。进入网页（https://groovy.apache.org/download.html）点击“Download”下载安装包，并进行解压（解压目录建议放到系统C盘）。

2.2 配置环境变量

Groovy与JDK类似，需要配置环境变量，配置方法同JDK环境变量配置。主要如下：

a）新建“GROOVY_HOME”变量，值为“Groovy安装目录”

b）编辑“PATH”变量，新增值“Groovy安装目录\bin”

2.3 测试安装

打开命令窗口，输入groovy -v，出现下图则表示安装成功。

三、Groovy程序编写与运行

1、执行工具

在windows系统中通过运行GroovyConsole.bat文件，来启动Groovy自带的程序编辑和执行界面。

当然，也可以通过IDEA等其他工具进行编辑和执行Groovy程序。

2、程序编写

2.1 文件格式

Groovy程序文件的文件名后缀为“.groovy”。

2.2 基本语法

2.2.1 注释

类型	格式
单行注释	//
多行注释	/* */
文档注释	/** */，文档注释适用于类、方法、属性生成说明文档

2.2.2 数据类型

Groovy 是一种动态语言，它在处理数据类型时非常灵活。Groovy 的数据类型可以分为原始类型（与 Java 相同的基本数据类型）和对象类型。Groovy 对类型系统进行了增强，使得开发者可以更加方便地操作数据。

2.2.2.1 原始类型

Groovy 继承了 Java 的原始数据类型，每一种原始数据类型都有一个对应的包装类。Groovy 会自动进行装箱和拆箱操作。

类型	说明
byte	8位有符号整数
short	16位有符号整数
int	32位有符号整数
long	64位有符号整数
float	32位单精度浮点数
double	64位双精度浮点数
char	16位Unicode字符
Boolean	布尔

2.2.2.2 对象类型

Groovy引入了一些特殊的数据类型来增强其灵活性和功能。

类型	说明	格式
String	能够使用单引号、双引号和三重引号定义字符串	‘内容’、”内容”、”””内容”””
Gstring	是Groovy特有的字符串，使用双引号或三重引号定义字符串，在字符串中能够使用变量或表达式	“str=${num}”或”””str=${num}”””
List	列表支持动态大小和不同类型的元素	[]，例如：[1, ‘f’, true]
Map	字典或映射，以键值对的形式存在	[:]
Range	范围类型，表示一系列连续的值，常用于循环和条件语句中	def str = 1..5 //表示1到5 def str = 1..<5 //表示1到5，但不包含5
Closure	闭包，是一种匿名代码块，可以作为传递参数或赋值给变量	def square = { int x -> x * x } def num = square(3) println(num) // 输出9
null	null表示没有对象

2.2.3 循环

在Groovy中，循环的格式与Java非常相似，但Groovy提供了一些额外的几种循环结构及其用法。且循环中常与range类型结合使用。

2.2.3.1 for循环

for(i in 0..<4){
  println(i)
}

2.2.3.2 while循环

int i = 0
while (i < 5) {
    println("i = $i")
    i++
}

2.2.3.3 do-while循环

int i = 0
do {
    println("i = $i")
    i++
} while (i < 5)

2.2.3.4 each方法

Groovy中的集合（如列表和范围）有一个each方法，用来迭代集合中的每个元素。这个方法在Groovy中非常常用。

def list = [1, 2, 3, 4, 5]
list.each { element ->  //element可以自定义，但是需要与$element相同
    println("Element: $element")
}

// 使用索引的eachWithIndex
list.eachWithIndex { element, index ->  //element和index可以自定义，但是需要与$element和$index相同
    println("Element: $element at index $index")
}

2.2.3.5 for-in循环

def list = [1, 2, 3, 4, 5]
for (element in list) {
    println("Element: $element")
}

2.2.3.6 times方法

times指执行特定代码的次数。

5.times {
    println(1)
}

2.2.3.7 upto方法

upto方法用于从一个数字递增到另一个数字。

1.upto(5){num -> println(num)}

2.2.3.8 downto方法

downto方法用于从一个数字递减到另一个数字。

5.downto(1){num -> println(num)}

2.2.4 条件表达式

在Groovy中，条件表达式与Java非常相似，但Groovy提供了一些更简洁的语法和增强的特性，使得条件表达式更为灵活和易读。以下是Groovy中常用的条件表达式及其相关语法：

2.2.4.1 if-else语句

def number = 10

if (number > 0) {
    println("The number is positive")
} else if (number < 0) {
    println("The number is negative")
} else {
    println("The number is zero")
}

2.2.4.2 if-else表达式

Groovy中的if-else可以作为表达式使用，这意味着它可以返回一个值。与三元运算符“? :”配合使用。

def number = 10
def result = number > 0 ? "Positive" : "Not Positive"
println(result)  // 输出 "Positive"

2.2.4.3 switch语句

Groovy中的switch语句与Java类似，但更加灵活。它不仅支持整数和字符，还可以使用字符串、布尔值、集合等进行匹配。

def x = 3
switch (x) {
    case 1:
        println("x is 1")
        break
    case 2:
        println("x is 2")
        break
    case 3:
        println("x is 3")
        break
    case [4, 5, 6]:
        println("x is 4, 5, or 6")
        break
    case "foo":
        println("x is 'foo'")
        break
    default:
        println("x does not match any case")
}

2.2.4.4 assert语句

Groovy中的assert语句用于测试条件，如果条件为假，程序将抛出AssertionError。这在调试和单元测试中非常有用。

def a = 5
assert a == 5        // 条件为真，不会抛出错误
assert a != 5 : "a is not 5"  // 条件为假，抛出带消息的AssertionError

2.2.4.5 Elvis 运算符

Elvis运算符（?:）是Groovy中特有的简化条件表达式的运算符。它类似于三元运算符，但更为简洁。

def name = 1
def displayName = name ? "known": "Unknown"
println(displayName)  // 输出 1

2.2.4.6 安全导航运算符

安全导航运算符指“?.”，用于在可能为null的对象上调用方法或访问属性，从而避免NullPointerException。

def person = null
def name = person?.name
println(name)  // 输出 "null"，而不会抛出异常

2.2.5 闭包

闭包在任意一种语言中都是一个非常重要的概念，Groovy中的闭包类似于Java中的匿名内部类或者其他语言中的Lambda表达式。闭包是可以传递的代码块，它可以捕获其上下文环境，并在以后执行时使用这个环境。闭包可以作为方法的参数、方法的返回值，甚至可以赋值给变量。闭包可以访问自身之外的变量，也可以接受参数和返回值。

闭包的基本语法为：

//{参数列表 -> 代码块}

def printtext = { name, age -> println("hello $name, you`s age is $age") }

printtext("xiaoli", 11)

2.2.5.1 特点

闭包具有参数灵活、访问外部变量和具备返回值的特点。参数灵活指闭包支持隐式参数“it”，当闭包只有一个参数时可省略参数列表，提供了极大方便。访问外部变量指闭包可以访问上下文中的环境变量。具备返回值指闭包中最后一个表达式的值将作为闭包的返回值。

def name = "xiaoli"
def printtext = { age ->
    println("hello $name, your age is $age")
    age = age + 1
}

age = printtext(11)

println("Your sister is $age years old")

2.2.5.2 使用场景

Groovy闭包常用于对集合对象的操作，例如each、collect、find等方法，也常用于事件驱动和构建DSL。

2.2.6 函数声明与调用

Groovy函数的声明与调用与Java非常相似。声明函数的关键字是def。

def hello(){//使用def声明函数
    println("hello")
}

hello()  //函数的调用

2.2.6.1 带参函数

与其他语言一样，一定支持带参数的函数声明。并能够返回值，但是返回值为多个则需要借助列表、数组等实现返回。

def printmsg(String name, int age){//使用def声明函数
    namemsg = "名字为：${name}"
    println(namemsg)
    agemsg = "年龄为：${age}"
    println(agemsg)
    return [namemsg, agemsg] //Groovy中函数返回多个值需要借助列表、数组、映射等实现
}

text = printmsg("李四", 14)
for(i in text){
    println(i)
}

2.2.6.2 带参（闭包）函数

Groovy中还可以将闭包作为参数传入函数中。

//方法中定义了一个闭包（Closure），名为operation
def performOperation(int a, int b, Closure operation, Closure operation1) {
    operation(a, b)
    //println(operation(a, b))
    operation1(a, b)
}
/*方法中将闭包作为参数传入的语法格式为：方法名(普通参数){闭包}
* 如果是多个闭包作为参数，则一次排序即可
*/
def result = performOperation(5, 3) { x, y -> x * y } { x, y -> x + y }
println result // 输出 8，虽然在方法中有两个闭包被执行，但是，方法最后一个表达式的值将作为返回值被返回

2.2.6.3 带可变参数函数

Groovy中有一种函数是带有可变参数。

//方法中定义了一个闭包（Closure），名为operation
def performOperation(int a, int b, Closure operation, Closure operation1) {
    operation(a, b)
    //println(operation(a, b))
    operation1(a, b)
}
/*方法中将闭包作为参数传入的语法格式为：方法名(普通参数){闭包}
* 如果是多个闭包作为参数，则一次排序即可
*/
def result = performOperation(5, 3) { x, y -> x * y } { x, y -> x + y }
println result // 输出 8，虽然在方法中有两个闭包被执行，但是，方法最后一个表达式的值将作为返回值被返回

2.2.7 类声明

Groovy类与Java相似，使用“class”声明类。声明类时，类名一般采用“驼峰命名法”，基本语法格式为：

class FirstClass{
    //成员变量
    String name1
    /**构造函数，通过构造函数向类传递参数，下面构造函数中“name”对应外面中传给类的参数
     * 而“name1”是成员变量，通过构造函数将“name”赋值给“name1”，供类中其他函数使用*/
    FirstClass(String name){
        this.name1 = name
    }
    //普通方法
    void printtext(){
        println("${name1}你好，我是构造函数FirstClass")
    }
}

def str = new FirstClass("xiaoli")

println(str.printtext())

会逃跑的乌龟

关注

16
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
Groovy动态语言

Groovy是用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，也可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。/*Java代码*//*Groovy代码*/Groovy是JVM的一个替代语言，使用方式基本与Java代码的方式相同，该语言特别适合与Spring的动态语言支持一起使用。
复制链接

扫一扫