Groovy 简介

Groovy 是 Apache 旗下的一门基于 JVM 平台的动态编程语言,在语言的设计上 Groovy 吸纳了 Python、Ruby 和 Smalltalk 语言的优秀特性,语法非常简练和优美,开发效率也非常高。Groovy 可以与 Java 语言无缝对接,Groovy 脚本里可以写 Java 代码,也可以在 Java 程序里调用 Groovy 脚本,两者的无缝衔接有效地降低了 Java 开发者学习 Groovy 的成本。Groovy 代码能够与Java 代码很好地结合,Groovy 支持99%的 Java 语法,但是 Groovy 并不会替代 Java,而是相辅相成、互补的关系,具体使用哪门语言这取决于要解决的问题和使用的场景。

Groovy 是 用于 Java 虚拟机的一种敏捷的动态语言,它是一种成熟的面向对象编程语言,既可以用于面向对象编程,又可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码,同时又具有闭包和动态语言中的其他特性。在Java中要输出"hello world"需要像下面这样,创建一个类,然后创建一个main方法:

public class Hello {
    public static void main(String[] args) {
        System.out.println("hello world");
    }
}

在Groovy中,这些都可以省略,下面这4种方式都可以输出“hello world”。

System.out.println("hello world");
System.out.println "hello world";

println("hello world")
println 'hello world'

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

下面介绍一下一些通用的Groovy语法。

1、不需要分号

学过C/C++/java的同学都会对分号很熟悉,我们使用的如此频繁,几乎放在每一行的末尾,然而在Groovy中分号是可选的,你可以省略他们。

2、return关键字可省略

在 Groovy 中,方法的最后一句表达式可作为返回值返回,而不需要return关键字。

String sayHello() { return "hello world!" }

String sayHello() { "hello world!" }

3、def 和 类型

作为动态语言,Groovy 中所有的变量都是对象,所有对象继承自java.lang.Object。在声明一个变量时,Groovy 不要求强制类型声明,仅仅要求变量名前使用关键字 def(在 Groovy 1 以前的版本中,甚至连 def 都不需要)。

def var="hello world"

println var

println var.class

由此可以看到程序最后输出了var的实际类型为:java.lang.String

备注:作为例外,方法参数和循环变量的声明不需要def。

4、数组初始化语法

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

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

而应该是下面这样

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

5、Getters and Setters

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()

备注:当你对getter/setter方法有特殊要求,你尽可提供自己的方法,Groovy默认的getter/setter方法会被替换。

6、包访问权限

在 Java 中如果没有显式的指定访问修饰符(public、protected、private)那么默认是包访问权限,但在 Groovy 中默认是public的,所以需要使用@PackageScope注解。

class Person {
    @PackageScope String name
}

7、使用命名的参数初始化Bean

class Student {
    String name
    int age
}

初始化一个实例的时候你可能会这样写:

def student = new Student()
student.name = "Tom"
student.age = 20

其实你可以用带命名的参数的默认构造器,会大大减少代码量:

def student = new Student(name: "Tom", age: 20)

8、使用with()来重复某一个操作

当更新一个实例的时候,你可以使用with()来省略相同的前缀,在Java中你必须这样写:

server.name = application.name
server.status = status
server.sessionCount = 3
server.start()
server.stop()

Groovy中则可以使用with():

server.with {
    name = application.name
    status = status
    sessionCount = 3
    start()
    stop()
}

9、Equals 和 ==

Java里的==等同于Groovy里的is()方法,Groovy中的==是更智能的equals(),比较两个类的时候,你应该使用a.is(b),而不是==。Groovy中的==可以自动避免NullPointerException异常,如下所示:

替换

status != null && status.equals(ControlConstants.STATUS_COMPLETED)

status == ControlConstants.STATUS_COMPLETED

10、字符串

在Groovy种有两种字符串类型,普通字符串(java.lang.String)和插值字符串(groovy.lang.GString)。

普通字符串使用单引号

println 'hello'

插值字符串使用双引号

def name = '张三'
println "hello $name"

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

def lines = '''line one
        line two
            line three
'''
println lines 

// 可以写成下面这种形式,可读性更好,\表示连字符
def lines = '''\
line one
    line two
line three
'''
println lines 

11、函数

Groovy 函数的返回类型可以不声明,默认返回最后一行代码的运行结果,但需要在声明函数的时候添加def关键字。反之,如果在声明函数中定义了返回值类型则可以省略def关键字,但函数中则必须使用return返回正确的数据类型。如下所示:

(1)函数定义时,参数的类型也可以不指定。例如:

//无需指定参数类型
String myFunction(arg1,arg2){
  ...
}

(2)除了变量定义可以不指定类型外,Groovy中函数的返回值也可以是无类型的。比如:

//无类型的函数定义,必须使用def关键字
def myFunction(){
    //最后一行代码的执行结果就是本函数的返回值
    last_line   
}

//如果指定了函数返回类型,则可不必加def关键字来定义函数,但是必须有return。
String  getString(){
   return "I am a string"
}

注意,如果函数定义时候指明了返回值类型的话,函数中则必须返回正确的数据类型,否则运行时报错。如果使用了动态类型的话,你就可以返回任何类型了。

Groovy 方法的其他特性与Java一样,比如支持重载、不定长参数(...)等。

12、闭包

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 }

标签: none

站长收徒,2021年第1期,限时优惠,截止到1月25日,错过再等半年>>>>>>






添加新评论