从Java到Groovy——Differences with Java

最新推荐文章于 2022-05-02 15:23:37 发布

xu_fu

最新推荐文章于 2022-05-02 15:23:37 发布

阅读量877

点赞数

Differences with Java

原文http://www.groovy-lang.org/differences.html

Groovy尽可能让Java开发者感到自然，我们试着遵守下面的原则，在设计Groovy的时候减少出乎意料。特别是对有Java背景的开发人员。

1. Default import

所有这些包和类默认被导入，所以你不需要显式使用import声明来导入他们：

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

2. Multi-methods

在Groovy里，调用的方法是在运行时决定的，这个叫做runtime dispatch或者multi-methods，就是说方法会基于运行时参数的类型进行选择，在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运行时选择，也就是o是一个String，所以会调用String参数的版本。

3. Array initializers

在Groovy，{...}代码块用来给闭包使用，这表示你不能用下面的语法创建数组：

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

你需要用：

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

4. Package scope visibility

在Groovy，忽略字段的修饰符不会像Java一样有默认的包权限

class Person {
    String name
}

其实他用来创建一个属性，即私有的字段，一个关联的getter和setter。

可以通过声明@PackageScope来创建一个包权限的字段：

class Person {
    @PackageScope String name
}

5.ARM blocks

ARM(Automatic Resource Management)block from Java 7在Groovy中不支持。但是，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
   }
}

6.Inner classes

匿名内部类和嵌套类的实现遵守Java的规则，但是你不应该搬出Java的语法.实现规则与我们在groovy.lang.Closure里做的很像，有好处也有不同，访问私有字段和方法可能是个问题，但是另一面私有变量不需要是final的。

6.1 Static innner classes

下面是一个静态内部类的例子：

class A {
    static class B {}
}

new A.B()

使用静态内部类是最支持的一个，如果你需要一个内部类，你应该将它声明成静态的。

6.2 Anonymous Inner Classes

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 Creating Instances of Non-Static Inner Classes

在Java里我们可以这样做：

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

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支持调用一个有参数的函数但不提供参数值，这个参数就会有一个空值，调用构造函数是同样的规则，使用new X()而不是new X(this)会有潜在的危险。虽然这很常见，但是我们还没有想出一个好办法来避免这个问题。

7.Lambdas

Java 8 支持lambdas和方法引用：

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

Java 8 lambdas可以或多或少看作匿名内部类，Groovy 不支持这个语法，但是有闭包：

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

8.GStrings

双引号里的字符串会被解释为GString类型，如果一个类有String类型的字面量，包含一个美元字符，用Groovy或者Java编译器编译，Groovy会返回编译错误或者生成有细微差别的代码。

通常，Groovy会自动转换GString和String，如果一个API声明了一个参数，像Java API里接受一个Object参数，然后检查它的实际类型。

9.String and Character literals

在Groovy里单引号的字面量作为String来使用，双引号的是String或者GString,取决于字面量里是否有插值。

assert 'c'.getClass()==String
assert "c".getClass()==String
assert "c${1}".getClass() 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支持两种风格的转换，Groovy风格的转换更加宽松。

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