Groovy系列（2）- Groovy与Java的不同之处

Groovy与Java的不同之处

默认 imports

所有这些包和类都是默认导入的，不必使用显式import语句来使用它们

java.io.*

java.lang.*

java.math.BigDecimal

java.math.BigInteger

java.net.*

java.util.*

groovy.lang.*

groovy.util.*

运行时分派

在Groovy中，将在运行时选择将被调用的方法。这称为运行时分派或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中, 得到：2，而在Groovy中：1

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

数组初始化

在Groovy中，{...}块是为闭包而保留的。这意味着不能使用以下语法创建数组：

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

必须使用：

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

自动资源管理块

roovy不支持Java中的ARM（自动资源管理）块。相反，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

   }

}

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

GStrings

由于双引号字符串字面量被解释为GString，Groovy将在GString和String之间自动转换
Groovy中的单引号用于String，双引号结果是String或GString，取决于文字中是否有插值

assert 'c'.getClass()==String

assert "c".getClass()==String

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

只有在赋给char类型的变量时，Groovy会自动将单字符String转换为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的情况下，在转换multi-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使用Objects来做每一件事，它对原始的引用自动包装。因此，它不遵循Java的扩展优先于装箱。这里有一个使用int的例子

int i

m(i)

//这是Java将调用的方法，因为扩展优先于装箱。

void m(long l) {

  println "in m(long)"

}

//这是Groovy实际调用的方法，因为所有的基本引用都使用它们的包装类。

void m(Integer i) {

  println "in m(Integer)"

}

==的行为

在Java中==表示对象的原始类型或标识的相等性。在Groovy ==翻译为a.compareTo(b)== 0，如果他们是可比较的，否则a.equals(b)。如果要检查身份，有is方法，例如a.is(b)