Groovy与Java的差异

默认导入

默认情况下导入所有下面这些包和类，你不必使用显式使用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);

在Groovy中：

assertEquals(1, result);

这是因为Java将使用静态信息类型，即o被声明为Object，而Groovy将在运行时选择实际调用方法，由于它是用String调用的，因此调用String版本的方法。

数组初始化

在Groovy中，{...}块保留用于闭包。这意味着你无法使用以下语法创建数组字面量：

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

你必须使用：

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

包访问权限

在Groovy中，省略字段上的修饰符不会导致像Java那样默认为包可见：

class Person {
    String name
}

相反为私有字段，但会创建属性相关的getter和setter方法。

可以通过使用@PackageScope注解来创建包可见字段：

class Person {
    @PackageScope String name
}

ARM块

Groovy不支持Java 7中的ARM（Automatic Resource Management/自动资源管理）块。相反，Groovy提供了依赖于闭包的各种方法，这些方法具有相同的效果且更简单。例如：

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.readLine()) != null) {
        System.out.println(line);
    }

} catch (IOException e) {
    e.printStackTrace();
}

可以像这样写：

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主导，但是你不应该删除Java语言规范并且不断地讨论不同的事情。现有实现看起来很像我们为groovy.lang.Closure做的，有一些好处和一些差异。例如，访问私有字段和方法可能会成为一个问题，但另一方面，局部变量并不一定是final类型的。

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)

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

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

Lambdas表达式

Java 8支持lambda和方法引用：

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

Java 8 lambdas可以或多或少地被视为匿名内部类。Groovy不支持该语法，但有闭包：

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

GStrings

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

虽然通常情况下，如果API声明了参数的类型，Groovy会在GString和String之间自动转换，但是要小心接收Object参数的Java API，并检查实际类型。

String和Character文字

Groovy中单引号文字会用String；而双引号文字会用String或GString，具体取决于文字中是否有插值。

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

只有在赋值给char类型的变量时，Groovy才会自动将单字符String转换为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支持两种类型的转换，在将类型转换为char的情况下，在转换多字符字符串时存在细微的差别。Groovy样式转换更宽松，将采用第一个字符，而C样式转换将失败，抛出异常。

// 对于单字符字符串，两者都是相同的
assert ((char) "c").class==Character
assert ("c" as char).class==Character

// 对于多字符字符串，它们不是
try {
  ((char) 'cx') == 'c'
  assert false: 'will fail - not castable'
} catch(GroovyCastException e) {
}
assert ('cx' as char) == 'c'
assert 'cx'.asType(char) == 'c'

元和包装类型

因为Groovy使用Objects来实现一切，所以所有基本类型都会自动转换为其包装类型来使用。Groovy不支持Java的扩展优先于包装的规则。这是一个使用int的例子：

int i
m(i)

void m(long l) {           // <1>
  println "in m(long)"
}

void m(Integer i) {        // <2>
  println "in m(Integer)"
}

<1>: 这是Java可以调用的方法，因为扩展优先于拆箱。

<2>: 这是Groovy实际调用的方法，因为所有原始引用都使用它们的包装类。

==的行为

在Java中==表示基本类型或对象引用的相等性。在Groovy中，如果它们是Comparable则==转换为a.compareTo(b)==0，否则转换为a.equals(b)。如果需要判断对象引用相等性，可以使用is函数，例如：a.is(b)。

转换

Java会自动扩展和缩小转换次数。

Java转换：

‘Y’：表示Java可以进行的转换
‘C’：表示Java在有显式强制转换时可以进行的转换
‘T’：表示Java可以进行的转换但数据被截断
‘N’：表示Java无法进行的转换

Groovy转换：

‘Y’：表示Groovy可以进行的转换
‘D’：表示Groovy在动态编译或显式强制转换时可以进行的转换
‘T’：表示Groovy可以进行的转换但数据被截断
‘B’：表示装箱/拆箱操作
‘N’：表示Groovy无法进行的转换

转换为boolean/Boolean时，截断使用Groovy Truth。从数字转换为字符会将Number.intvalue()转换为char。当从Float或Double转换时，Groovy使用Number.doubleValue()构造BigInteger和BigDecimal，否则使用toString()构造。其他转换的行为由java.lang.Number定义。

额外关键字

Groovy中的关键字比Java中的更多。不要将它们用于变量名称等。

• as
• def
• in
• trait

原文链接