Groovy入门学习记录

最新推荐文章于 2022-12-06 22:16:53 发布

wenbaoxie

最新推荐文章于 2022-12-06 22:16:53 发布

阅读量298

点赞数

分类专栏：实习

本文链接：https://blog.csdn.net/qq_34446716/article/details/109134988

版权

实习专栏收录该内容

47 篇文章 1 订阅

订阅专栏

Groovy 语言入门

主要是Groovy基本语言进行讲解，因为工作中要用到，简单做个记录
B站视频

IDEA中配置Groovy

1.首先下载Groovy的SDK
2.将下载到的SDK解压到文件目录，类似于JAVA SDK放置的目录
3.配置环境变量
如：
新建GROOVY_HOME变量名，变量值参考：C:\Program Files\groovy-2.5.8
在这里插入图片描述
之后在path中添加%GROOVY_HOME%\bin

4.配置完成保存后，在CMD中输入：groovy -v检查Groovy配置是否成功
以上唯一的注意点就是都是系统变量，或者用户变量，不要分开保存

5…在IDEA中配置Groovy工程环境
打开IDEA面板，在右下角依次选择Configure->Plugins打开Plugins配置面板，搜索groovy插件。默认情况下，新版IDEA已经自动集成了该插件，如下所示。若未集成则手动安装并重启IDEA即可。
在这里插入图片描述
然后我们新建一个Groovy工程，里面可以有java文件

下面提供一个参考：

/**
 * @Author wenbaoxie* @Date 2020/10/17
 */
class test {
    def s(){
        print("dd")
    }

    static void main(String[] args) {
        println 'hello world'
        def s = 1
        println(s)

        def a = 1
        assert a instanceof Integer

// Integer.MAX_VALUE
        def b = 2147483647
        assert b instanceof Integer

// Integer.MAX_VALUE + 1
        def c = 2147483648
        assert c instanceof Long

// Long.MAX_VALUE
        def d = 9223372036854775807
        assert d instanceof Long

// Long.MAX_VALUE + 1
        def e = 9223372036854775808
        assert e instanceof BigInteger
        // key虽然没有加引号，不过Groovy会默认将其转换为字符串
        def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF']

        assert colors['red'] == '#FF0000' // 使用中括号访问
        assert colors.green == '#00FF00' // 使用点表达式访问

        colors['pink'] = '#FF00FF' // 使用中括号添加元素，相当于Java Map 的 put(key,value)方法
        colors.yellow = '#FFFF00'// 使用点表达式添加元素
        assert colors.pink == '#FF00FF'
        assert colors['yellow'] == '#FFFF00'
        assert colors instanceof java.util.LinkedHashMap // 默认使用LinkedHashMap类型

// Groovy Map的key默认语法不支持变量，这里的key时间上是字符串'keyVal'而不是keyVal变量的值'name'
        def keyVal = 'name'
        def persons = [keyVal: 'Guillaume']
        assert !persons.containsKey('name')
        assert persons.containsKey('keyVal')

//要使用变量作为key，需要使用括号
        persons = [(keyVal):"Val"]
        assert persons.containsKey('name')
        assert !persons.containsKey('keyVal')
    }

}

基本语法

groovy是弱语言类型的

在 Groovy 中，{…} 语句块是留给闭包（Closure）使用的，所以不能像 Java 中一样使用下面这种方式初始化数组

int[] array = [1,2,3]

POJO

Groovy 语句无需使用分号（;）结尾，当然加上也不会报错，毕竟完全兼容 Java 的语法。
Groovy 中==等价于 Java 中的equals方法。

Groovy 中定义变量默认访问修饰符是public，变量定义时遵循 Java 变量命名规范，变量名以字母、下划线或美元符号 $开始，可以包含字母、数字、下划线和美元符号$ ，但关键字除外。除了这些规则之外，Groovy 定义变量时如果是一行定义一个类型，末尾的分号可以省略，但是如果多个变量占一行，变量之间必须以分号分割。

Groovy 定义变量的方式和 Java 是类似的，区别在于 Groovy 提供了def关键字供使用，它可以省略变量类型的定义，根据变量的值进行类型推导。

def a = 123
def b = 'b'
def c = true 
boolean d = false
int e = 123

如果定义变量的字面量值为数字时，类型会根据数字的大小自动调整

def a = 1
assert a instanceof Integer

// Integer.MAX_VALUE
def b = 2147483647
assert b instanceof Integer

// Integer.MAX_VALUE + 1
def c = 2147483648
assert c instanceof Long

// Long.MAX_VALUE
def d = 9223372036854775807
assert d instanceof Long

// Long.MAX_VALUE + 1
def e = 9223372036854775808
assert e instanceof BigInteger

Groovy为数字类型提供一种更简单的声明类型的方式：类型后缀

Integer 使用I或i
Long 使用L或l
BigInteger 使用G或g
BigDecimal 使用G或g
Double 使用D或d
Float 使用F或f
使用例子

def a = 123I
assert a instanceof Integer
def b= 123L
assert b instanceof Long

字符串
在Groovy种有两种字符串类型，普通字符串（java.lang.String）和插值字符串（groovy.lang.GString）。
普通字符串使用单引号

println ‘hello’
插值字符串使用双引号

def name = '张三'
println "hello $name" //注意是双引号 ...单引号输出的还是 hello $name

除此之外，还支持三单引号的写法，可以保留文本的换行及缩进格式

def strippedFirstNewline = '''line one
        line two
            line three
'''

println strippedFirstNewline
// 可以写成下面这种形式，可读性更好

def strippedFirstNewline2 = '''\
line one
    line two
line three
'''
println strippedFirstNewline2

字符
在 Groovy 中并没有明确的字符字面量表示形式，需要显示的指定，有三种方式

char c1 = 'A' // 声明类型
assert c1 instanceof Character

def c2 = 'B' as char // 用as关键字
assert c2 instanceof Character

def c3 = (char) 'C' // 强制类型转换
assert c3 instanceof Character

方法（函数）
Groovy 方法的默认访问修饰符是public，方法的返回类型可以不需要声明，但需添加def关键字。有返回值的方法return可以被省略，默认返回最后一行代码的运行结果，如果使用了return关键字则返回指定的返回值。

String method1() {
    return 'hello'
}
assert method1() == 'hello';

def method2() {
    return 'hello'
}
assert method2() == 'hello';

def method3() {
    'hello'
}
assert method3() == 'hello';

Groovy 方法的参数类型可以被省略，默认为Object类型。

def add(int a, int b) {
    return a + b
}
//与上面的等价
def add(a, b) {
    a + b
}

Groovy 方法的其他特性与Java一样，比如支持重载、不定长参数（…）等。

pojo

Groovy 默认会隐式的创建getter、setter方法，并且会提供带参的构造器，下面两者是等价的。

// In Java
public class Person {
    private String name;
    Person(String name) {
        this.name = name
    }
    public String getName() {
        return name
    }
    public void setName(String name) {
        this.name = name
    }
}

// In Groovy
class Person {
    String name
}

def person = new Person(name: '张三')
assert '张三' == person.name
person.name = '李四'
//person.setName('李四')
assert '李四' == person.getName()

内部类：

//静态内部类
class A {
    static class B {}
}
new A.B()

//匿名内部类
import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

CountDownLatch called = new CountDownLatch(1)

Timer timer = new Timer()
timer.schedule(new TimerTask() {
    void run() {
        called.countDown()
    }
}, 0)

assert called.await(10, TimeUnit.SECONDS)

闭包
Groovy 提供了闭包的支持，语法和 Lambda 表达式有些类似，简单来说就是一段可执行的代码块或函数指针。闭包在 Groovy 中是groovy.lang.Closure类的实例，这使得闭包可以赋值给变量，或者作为参数传递。Groovy 定义闭包的语法很简单，就像下面这样。

//闭包的参数为可选项
def closure = { [closureParameters -> ] statements }
闭包可以访问外部变量，而方法（函数）则不能。
def str = 'hello'
def closure={
    println str
}
closure()//hello

闭包调用的方式有两种，闭包.call(参数)或者闭包(参数)，在调用的时候可以省略圆括号。

def closure = {
    param -> println param
}
 
closure('hello')
closure.call('hello')
closure 'hello'

闭包的参数是可选的，如果没有参数的话可以省略->操作符。


def closure = {println 'hello'}
closure()

多个参数以逗号分隔，参数类型和方法一样可以显式声明也可省略。

def closure = { String x, int y ->                                
    println "hey ${x} the value is ${y}"
}

如果只有一个参数的话，也可省略参数的定义，Groovy提供了一个隐式的参数it来替代它。

def closure = { it -> println it } 
//和上面是等价的
def closure = { println it }   
closure('hello')

闭包可以作为参数传入，闭包作为方法的唯一参数或最后一个参数时可省略括号。

def eachLine(lines, closure) {
    for (String line : lines) {
        closure(line)
    }
}

eachLine('a'..'z',{ println it }) 
//可省略括号，与上面等价
eachLine('a'..'z') { println it }

在这里插入图片描述

闭包

在这里插入图片描述

it使用

在这里插入图片描述

owner使用

在这里插入图片描述

在这里插入图片描述
打印结果

在这里插入图片描述

def switchtest = 100
        switch (switchtest){
            case 100:
                println "100"
                break
            case [1,2,43]:
                println "[1,2,43]"
                break
            case [1:1,2:3]:
                println "[1:1,2:3]"
                break
            default:
                println "default"
                break
        }

元编程
在这里插入图片描述

@TypeChecked
class te{
    int i = 10.0  // 不加TypeChecked不会报错
}

在这里插入图片描述

安全访问

基本工具
在这里插入图片描述

sort闭包使用

findAll

collection

*使用，访问集合所有的元素

在这里插入图片描述

在这里插入图片描述
IO操作

读取内容

爬取网页内容

在这里插入图片描述

@CompileStatic
加以强化

设计模式

在这里插入图片描述

未完待续…

项目中用到了下面的这个
如果 Groovy 脚本文件里只有执行代码，没有类的定义，则 Groovy 编译器会生成一个 Script 的子类，类名和脚本文件的文件名一样，而脚本中的代码会被包含在一个名为run的方法中，同时还会生成一个main方法，作为整个脚本的入口。所以，作为 JVM 平台语言，与 Java 本质上还是一样的。

wenbaoxie

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Groovy入门学习记录

Groovy 语言入门主要是Groovy基本语言进行讲解，因为工作中要用到，简单做个记录B站视频IDEA中配置Groovy1.首先下载Groovy的SDK2.将下载到的SDK解压到文件目录，类似于JAVA SDK放置的目录3.配置环境变量如：新建GROOVY_HOME变量名，变量值参考：C:\Program Files\groovy-2.5.8之后在path中添加%GROOVY_HOME%\bin4.配置完成保存后，在CMD中输入：groovy -v检查Groovy配置是否成功
复制链接

扫一扫

专栏目录