与 Java 的区别

Groovy 试图尽可能地贴近 Java 开发者。在设计 Groovy 时，我们遵循了最小惊讶原则，特别是对于从 Java 背景学习 Groovy 的开发者。

这里我们列出了 Java 和 Groovy 之间的所有主要区别。

1. 默认导入

所有这些包和类都默认导入，即您无需使用显式的 import 语句即可使用它们

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

2. 多方法

在 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 版本。

3. 数组初始化器

在 Java 中，数组初始化器采用以下两种形式之一

int[] array = {1, 2, 3};             // Java array initializer shorthand syntax
int[] array2 = new int[] {4, 5, 6};  // Java array initializer long syntax

在 Groovy 中，{ … } 块保留给闭包。这意味着您不能使用 Java 的数组初始化器简写语法创建数组字面量。您可以使用 Groovy 的字面量列表表示法，如下所示

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

对于 Groovy 3+，您可以选择使用 Java 的数组初始化器长语法

def array2 = new int[] {1, 2, 3} // Groovy 3.0+ supports the Java-style array initialization long syntax

4. 包范围可见性

在 Groovy 中，省略字段上的修饰符不会像 Java 中那样导致包私有字段

class Person {
    String name
}

相反，它用于创建属性，也就是说，一个私有字段，一个关联的getter和一个关联的setter。

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

class Person {
    @PackageScope String name
}

5. ARM 块

Java 7 引入了 ARM（自动资源管理）块（也称为 try-with-resources）块，如下所示

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

从 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
   }
}

6. 内部类

匿名内部类和嵌套类的实现与 Java 非常接近，但存在一些差异，例如，从这些类中访问的局部变量不必是 final。我们在生成内部类字节码时，会利用一些用于 groovy.lang.Closure 的实现细节。

6.1. 静态内部类

这是一个静态内部类的例子

class A {
    static class B {}
}

new A.B()

静态内部类的使用是支持最好的。如果你绝对需要一个内部类，你应该把它变成一个静态的。

6.2. 匿名内部类

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)

6.3. 创建非静态内部类的实例

在 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 class Y {
    public class X {}
    public X foo() {
        return new X()
    }
    public static X createX(Y y) {
        return new X(y)
    }
}

不过要注意，Groovy 支持在不提供参数的情况下调用带一个参数的方法。参数将具有 null 值。基本上，相同的规则适用于调用构造函数。您可能会不小心写成 `new X()` 而不是 `new X(this)`。由于这也可能是常规方式，我们尚未找到一个好的方法来防止这个问题。

Groovy 3.0.0 支持 Java 风格的语法来创建非静态内部类的实例。

7. 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.each { println it } // or list.each(this.&println)

8. GString

由于双引号字符串字面量被解释为 GString 值，如果一个包含美元字符的 String 字面量类使用 Groovy 和 Java 编译器编译，Groovy 可能会出现编译错误或产生细微不同的代码。

虽然通常情况下，如果 API 声明了参数类型，Groovy 会在 GString 和 String 之间自动转换，但请注意那些接受 Object 参数然后检查实际类型的 Java API。

9. 字符串和字符字面量

Groovy 中的单引号字面量用于 String，双引号字面量则根据字面量中是否存在插值而生成 String 或 GString。

assert 'c'.class == String
assert "c".class == String
assert "c${1}".class in GString

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 风格的转换会抛出异常。

// 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'

10. `==` 的行为

在 Java 中，== 表示基本类型的相等或对象的身份。在 Groovy 中，== 在所有地方都表示相等。对于非基本类型，当评估 Comparable 对象的相等性时，它会转换为 a.compareTo(b) == 0，否则为 a.equals(b)。

要检查身份（引用相等），请使用 is 方法：a.is(b)。从 Groovy 3 开始，您还可以使用 === 运算符（或否定版本）：a === b（或 c !== d）。

11. 基本类型和包装器

在一个纯粹的面向对象语言中，一切都将是对象。Java 的立场是，像 int、boolean 和 double 这样的基本类型使用非常频繁，值得特殊处理。基本类型可以高效地存储和操作，但不能在所有可以使用对象的地方使用。幸运的是，Java 在基本类型作为参数传递或用作返回类型时会自动装箱和拆箱

public class Main {           // Java

   float f1 = 1.0f;
   Float f2 = 2.0f;

   float add(Float a1, float a2) { return a1 + a2; }

   Float calc() { return add(f1, f2); } (1)

    public static void main(String[] args) {
       Float calcResult = new Main().calc();
       System.out.println(calcResult); // => 3.0
    }
}

1	`add` 方法需要包装器类型和基本类型参数，但我们提供的是基本类型和包装器类型。同样，`add` 的返回类型是基本类型，但我们需要包装器类型。

Groovy 也一样

class Main {

    float f1 = 1.0f
    Float f2 = 2.0f

    float add(Float a1, float a2) { a1 + a2 }

    Float calc() { add(f1, f2) }
}

assert new Main().calc() == 3.0

Groovy 也支持基本类型和对象类型，但是，它在推动面向对象纯洁性方面更进一步；它努力将一切都视为一个对象。任何基本类型变量或字段都可以像对象一样对待，并且会根据需要自动包装。虽然基本类型可能在底层使用，但只要可能，它们的使用应该与普通对象的使用没有区别，并且会根据需要进行装箱/拆箱。

这是一个使用 Java 尝试（在 Java 中不正确地）解引用基本类型 float 的小例子

public class Main {           // Java

    public float z1 = 0.0f;

    public static void main(String[] args){
      new Main().z1.equals(1.0f); // DOESN'T COMPILE, error: float cannot be dereferenced
    }
}

相同的例子使用 Groovy 编译并成功运行

class Main {
    float z1 = 0.0f
}
assert !(new Main().z1.equals(1.0f))

由于 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 实际调用的方法，因为所有基本类型引用都使用它们的包装类。

11.1. 使用 `@CompileStatic` 进行数值基本类型优化

由于 Groovy 在更多地方转换为包装类，您可能想知道它是否会为数值表达式生成效率较低的字节码。Groovy 有一套高度优化的类用于进行数学计算。当使用 @CompileStatic 时，仅涉及基本类型的表达式使用与 Java 相同的字节码。

11.2. 正/负零的边界情况

Java 浮点/双精度操作（包括基本类型和包装类）遵循 IEEE 754 标准，但存在一个有趣的边界情况，涉及正零和负零。该标准支持区分这两种情况，虽然在许多场景中程序员可能不关心差异，但在某些数学或数据科学场景中，区分它们很重要。

对于基本类型，Java 在比较这些值时会映射到特殊的字节码指令，该指令具有“正零和负零被认为是相等的”属性。

jshell> float f1 = 0.0f
f1 ==> 0.0

jshell> float f2 = -0.0f
f2 ==> -0.0

jshell> f1 == f2
$3 ==> true

对于包装类，例如 java.base/java.lang.Float#equals(java.lang.Object)，在这种情况下结果为 false。

jshell> Float f1 = 0.0f
f1 ==> 0.0

jshell> Float f2 = -0.0f
f2 ==> -0.0

jshell> f1.equals(f2)
$3 ==> false

Groovy 一方面试图紧密遵循 Java 的行为，另一方面又在更多地方自动在基本类型和包装等价物之间切换。为避免混淆，我们建议遵循以下准则

如果您希望区分正零和负零，请直接使用 equals 方法，或者在使用 == 之前将任何基本类型转换为其包装等价物。
如果您希望忽略正负零之间的差异，请直接使用 equalsIgnoreZeroSign 方法，或者在使用 == 之前将任何非基本类型转换为其基本类型等价物。

这些指导原则在以下示例中进行说明

float f1 = 0.0f
float f2 = -0.0f
Float f3 = 0.0f
Float f4 = -0.0f

assert f1 == f2
assert (Float) f1 != (Float) f2

assert f3 != f4         (1)
assert (float) f3 == (float) f4

assert !f1.equals(f2)
assert !f3.equals(f4)

assert f1.equalsIgnoreZeroSign(f2)
assert f3.equalsIgnoreZeroSign(f4)

1	请记住，对于非基本类型，`==` 映射到 `.equals()`

12. 转换

Java 进行自动扩大和缩小转换。

表 1. Java 转换
	转换为
从	布尔	字节	短整型	字符	整数	长整型	浮点型	双精度型
布尔	-	N	N	N	N	N	N	N
字节	N	-	Y	C	Y	Y	Y	Y
短整型	N	C	-	C	Y	Y	Y	Y
字符	N	C	C	-	Y	Y	Y	Y
整数	N	C	C	C	-	Y	T	Y
长整型	N	C	C	C	C	-	T	T
浮点型	N	C	C	C	C	C	-	Y
双精度型	N	C	C	C	C	C	C	-

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

Groovy 在这方面进行了极大的扩展。

表 2. Groovy 转换
	转换为
从	`布尔`	`布尔`	`字节`	`字节`	`短整型`	`短整型`	`字符`	`字符`	`整数`	`整数`	`长整型`	`长整型`	`大整数`	`浮点型`	`浮点型`	`双精度型`	`双精度型`	`大十进制`
`布尔`	-	B	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N
`布尔`	B	-	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N	N
`字节`	T	T	-	B	Y	Y	Y	D	Y	Y	Y	Y	Y	Y	Y	Y	Y	Y
`字节`	T	T	B	-	Y	Y	Y	D	Y	Y	Y	Y	Y	Y	Y	Y	Y	Y
`短整型`	T	T	D	D	-	B	Y	D	Y	Y	Y	Y	Y	Y	Y	Y	Y	Y
`短整型`	T	T	D	T	B	-	Y	D	Y	Y	Y	Y	Y	Y	Y	Y	Y	Y
`字符`	T	T	Y	D	Y	D	-	D	Y	D	Y	D	D	Y	D	Y	D	D
`字符`	T	T	D	D	D	D	D	-	D	D	D	D	D	D	D	D	D	D
`整数`	T	T	D	D	D	D	Y	D	-	B	Y	Y	Y	Y	Y	Y	Y	Y
`整数`	T	T	D	D	D	D	Y	D	B	-	Y	Y	Y	Y	Y	Y	Y	Y
`长整型`	T	T	D	D	D	D	Y	D	D	D	-	B	Y	T	T	T	T	Y
`长整型`	T	T	D	D	D	T	Y	D	D	T	B	-	Y	T	T	T	T	Y
`大整数`	T	T	D	D	D	D	D	D	D	D	D	D	-	D	D	D	D	T
`浮点型`	T	T	D	D	D	D	T	D	D	D	D	D	D	-	B	Y	Y	Y
`浮点型`	T	T	D	T	D	T	T	D	D	T	D	T	D	B	-	Y	Y	Y
`双精度型`	T	T	D	D	D	D	T	D	D	D	D	D	D	D	D	-	B	Y
`双精度型`	T	T	D	T	D	T	T	D	D	T	D	T	D	D	T	B	-	Y
`大十进制`	T	T	D	D	D	D	D	D	D	D	D	D	D	T	D	T	D	-

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

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

13. 额外关键字

Groovy 拥有许多与 Java 相同的关键字，并且 Groovy 3 及更高版本也拥有与 Java 相同的 var 保留类型。此外，Groovy 还有以下关键字

as
def
in
trait
it // 在闭包内部

Groovy 不像 Java 那样严格，它允许某些关键字出现在在 Java 中是非法的位置，例如以下是有效的：var var = [def: 1, as: 2, in: 3, trait: 4]。尽管如此，我们不鼓励您在可能引起混淆的地方使用上述关键字，即使编译器可能接受。特别是，避免将它们用于变量、方法和类名，因此我们之前的 var var 示例将被视为不良风格。

有关关键字的更多文档可用。