Groovy 脚本

SKKeith
801 阅读7分钟

前言

Groovy 试图对于Java开发者更加友好。因此在设计groovy时，试图遵循最小差异的原则，尤其是对于拥有Java基础的人来学习Groovy.

Default imports

所有的packages 和 class 都是默认导入，也就是说，你不必要使用一个明确的import语法来使用：

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

多态方法

在Groovy开发者开来，运行时被调用的方法都是被选择的。这些被称为运行时调度或多态方法。这意味着方法会基于运行时参数类型被选择调用。在Java中，情况正好相反，方法在编译时被选择调用，基于声明的类型。

在下述代码中，使用Java代码填写，可以被java和Groovy编译。但是它将表现的不一致：

int method(String arg) {
	return 1;
}
int method(Object arg) {
	return 2;
}
Object o = "Object";
int result = method(o);

在Java中，你将使用

assertEquals(2, result); //Java识别到的是Object类型

而在Groovy中

assertEquals(1, result); //Groovy识别到的是String类型

这是因为Java使用静态语法类型，意味着o被定义为Object,而当方法真实使用时，Groovy将在运行时被选择类型为String.

数组初始化设值

在Java中，数组初始化采用两种方式：

int[] array = {1,2,3}; //快速方式
int[] array2 = new intp[]{4,5,6}; //长语法

在 Groovy中，{...} 代码块为闭包保留。这意味着你在使用Java数组快速语法赋设定值时，不可以创建数组自变量。你取代使用Groovy的自变量列表，如：

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

对于Groovy 3+的版本，你可以选择使用Java数组长语法的初始化自变量方法。

def array2 = new int[]{1,2,3};//Groovy 	3.0+支持长语法

包范围可见性

在Groovy 中，对变量省略修饰词不会导致包私有化成员变量的现象，如Java中：

class Person { String name }

反而，它常用于创建一种属性，标识为一个私有变量，一个有关联的getter和setter. 在Groovy中，使用@PackageScope 来创建一个有关联的私有包变量。

class Person {
	@PackageScope String name
}

ARM块

Java 7 介绍了ARM(Automatic Resource Management) blocks, 比如这个：

Path file = Paths.get("/path/to/file");
Charset charset = Charset.forName("UTF-8");
try(BufferedReader reader = Files.newBufferedReader(file, charset)) {
	String line;
	while ((line = reader.reader.readLine() != null)) {
		System.out.println(line);
	}
}catch (IOException e) {
	e.printStackTrace();
}

上述代码块在Groovy 3+版本中也支持。但是，Groovy 提供了更多元的方法闭合依赖，即实现相同效果的习语表达。比如：

new File('/path/to/file').eachLine('UTF-8') {
	println it
}

或者，如果你想要的Java的闭包版本：

new File('/path/to/file').withReader('UTF-8') {
	reader -> 
		reader.eachLine {
			println it
		}
}

内部类

匿名内部类的实现和嵌套类遵循Java，但是还有些差别。比如从该类类中的局部变量不用是final。 在生成内部类字节码时，我们利用了groovy.lang.Closure的 一些实现细节。

静态内部类

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 TimeTask() {
	void run() {
		called.countDown()
	}
}, 0)
assert called.await(10, TimeUnit.SECONDS)

创建一个非静态的内部类实例

在Java中：

public class Y{
	public class X {}
	public X foo() {
		return new X();
	}
	public static X createX(Y y) {
		return y.new X();
	}
}

在3.0.0之前的版本,Groovy不支持 y.new X() 标识。反而，你必须写new X(y),就像如此：

public clas Y {
	public class X{}
	public X foo(){
		return new X()
	}
	public static X createX(Y y){
		return new X(y)
	}
}

需要注意的是，Groovy 支持使用一个参数调用方法，而不提供参数。然后参数的值将为空。基本上相同的规则也适用于调用构造函数。例如：您可能会编写 new () 而不是new X(this).因为这也可能是一种常规的方法，我们还没找到一个好的方法来防止这个问题。 Groovy 3.0.0 支持Java风格的语法来创建非静态内部类的实例。

Lambda表达式和方法引用运算符

Java 8+支持lambda 表达式和方法引用运算符(::)

Runnable run = () -> System.out.println("Run");//Java
list.forEach(System.out::println);

Groovy 3 和更高的版本在Parrot解析器中也支持这些功能。在Groovy的早期版本中，应该使用闭包代替：

Runnable run = {println 'run'}
list.forEach {println it}// or list.each(this.&println)

GStrings

由于双引号字符串文本会被解释为GString数值，如果使用Groovy 和Java编译器包含美元字符的字符串文本的类，Groovy可能会因为编译错误而报错，或者生成细微不同的代码。

尽管Groovy通常在GString 和String之间自动转换(如果API 声明了参数的类型)，但要注意接收对象的JavaAPI,然后检查实际的类型。

String 和 Character 自变量

Groovy中的单引号自变量用于String，双引号结果用于String或GString，这取决于自变量中是否有补充插入。

assert 'c'.getClass()==String
assert "c".getClass()==String
assert "c${1}".getClass() in GString

Groovy只有在分配给char类型的变量时才会自动将单个字符串转换为char。当使用char类型的参数调用方法时，我们需要显式转换或确保值已提前转换。

char a='a'
assert Character.digit(a, 16)==10 : 'But Groovy does boxing'
assert Character.digit((char) 'a', 16)==10

try {
  assert Character.digit('a', 16)==10
  assert false: 'Need explicit cast'
} catch(MissingMethodException e) {
}

Groovy支持两种类型的casting，在casting 转化为char的情况下，在casting多char字符串时有细微的差别。Groovy样式的转换更为宽松，将使用第一个字符，而C的方式转换将异常失败。

// for single char strings, both are the same
assert ((char) "c").class==Character
assert ("c" as char).class==Character

// for multi char strings they are not
try {
  ((char) 'cx') == 'c'
  assert false: 'will fail - not castable'
} catch(GroovyCastException e) {
}
assert ('cx' as char) == 'c'
assert 'cx'.asType(char) == 'c'

基础类型和封装类型

因为Groovy对所有东西都使用对象，所以它自动包装对原语的引用。因此，它不遵循Java的扩展优先于装箱的行为。下面是一个使用int的例子

int i
m(i)

void m(long l) {        //①    
  println "in m(long)" 
}

void m(Integer i) {        //②
  println "in m(Integer)"
}

① 这是Java将调用的方法，因为加宽优先于取消装箱。 ② 这是Groovy实际调用的方法，因为所有原语引用都使用它们的包装类。

行为 ==

在Java中，==表示对象的基元类型或标识的相等性。在Groovy==中，在所有情况下都表示相等。当计算可比较对象的相等性时，它转换为a.compareTo（b）==0，否则转换为a.equals（b）。要检查标识（引用相等），请使用is方法：a.is（b）。在Groovy 3中，您还可以使用===操作符（或取反版本）：a===b（或c！==d）。

转变

Java会自动扩大和缩小转换范围。

Converts from booleanbyte short char int long float double booleanbyte - N N N N N N N byte N - Y C Y Y Y Y short N C - C Y Y Y Y char N C C - Y Y Y Y int N C C C - Y T Y long N C C C C - T T float N C C C C C - Y double N C C C C C C -

Converts from boolean byte short char int long float double
boolean - N N N N N N N
byte N - Y C Y Y Y Y
short N C - C Y Y Y Y
char N C C - Y Y Y Y
int N C C C - Y T Y
long N C C C C - T Y
float N C C C C C - Y
double N C C C C C C -

“Y”表示Java可以进行的转换，“C”表示Java在显式转换时可以进行的转换，“T”表示Java可以进行的转换，但数据被截断，“N”表示Java无法进行的转换。

额外的关键词

Groovy有许多与Java相同的关键字，Groovy 3也有与Java相同的var保留类型。此外，Groovy还有以下关键字：

as
def
in
trait
it // within closures

Groovy没有Java严格，因为它允许一些关键字出现在Java中非法的地方，例如：var=[def:1，as:2，in:3，trait:4]。更重要的是，即使编译器很高兴，您也不希望在可能导致混淆的地方使用上述关键字。特别是，避免将它们用于变量、方法和类名，因此我们以前的var-var示例将被视为糟糕的样式。

参考Groovy官网

avatar
文章
阅读
粉丝