Groovy和Java的区别

Groovy对Java开发者来说是尽可能的自然过渡。Groovy设计者设计Groovy时，遵循最小改变原则，尤其是有Java开发背景的开发者学习Groovy时。
如下列出了Java和Groovy的主要不同
本文所有测试基于groovy 2.5.3, JVM 1.8.0_73

1.默认导入(Default imports)

所有列出来的包和类在Groovy中是默认导入的，不用明确的使用import声明。

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

2.多方法(Multi-methods)

Multi-methods,暂且成为多方法。
在Groovy中，调用哪个方法是在运行时选择的。这被叫做运行时调度(runtime dispatch)或者多方法(multi-method)。也就是方法选择基于参数运行时类型的。在Java中，正好相反，方法选择是在编译的时候，是基于声明的类型。
如下的代码是以java代码编写，在Java和Groovy中都可以编译通过，但是表现却不同：

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

在Java中，因为是基于编译是声明的类型，所以o被当做Object类型(尽管实际类型是String)，所以调用第二个method方法：

assertEquals(2, result);

在Groovy中，因为是基于运行时参数类型的，所以o被当做String类型，调用第一个method方法：

assertEquals(1, result)

3.数组初始化(Array initializers)

在Groovy中，{ ... }块是代表闭包的。所以不能使用此来当做创建数组的语法：
如下是错误的：

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

必须如下使用：

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

4.包的访问范围(package scope visibility)

在Groovy中，省略一个字段的修饰符并不会像Java中那样代表是包内私有的字段。就是不会像java那样在同一个包呢可以直接访问。

class Person {
    String name
}

在Groovy中，如上的字段声明只是用来创建一个属性，一个默认关联了getter和setter方法的私有属性。
如果要创建一个包内私有的属性，需要使用注解@PackageScope:

class Person {
    @PackageScope String name
}

因为在groovy中，访问权限默认都是public的，经过测试，增加了@PackageScope的属性不起作用，仍然是public访问权限的。测试groovy的版本是:
Groovy Version: 2.5.3 JVM: 1.8.0_73 Vendor: Oracle Corporation OS: Mac OS X

5.自动资源管理块(ARM Block)

从Java 7开始支持的ARM (Automatic Resource Management) 块Groovy不支持。取而代之，Groovy提供了基于闭包的各种方法，这些方法和ARM块有相同的作用却更加简洁。例如：

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中可以如下编写：

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)

Groovy对匿名内部类和嵌套类的实现遵循了Java的特点，但是并没有完全遵照Java语言的规范，所以他们之间是不同的。其实现和java.lang.Closure非常相似，也有某些优点和不同。例如访问私有字段和方法可能会比较麻烦，但从另一面来说，局部变量不必非得是final修饰的。

6.1 静态内部类(Static inner classes)

如下是静态内部类的例子：

class A {
    static class B {}
}
new A.B()

Groovy对静态内部类的使用提供了很好的支持。如果你需要使用内部类，优先考虑静态内部类。

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)

如上是匿名内部类，跟java基本一样。

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支持调用包含一个参数的方法时不传任何参数。参数值为空值。但是对于原生类型，会报错。当参数是原生类型对应的包装类型是，就不会有问题了，当然如果是对象也没有问题。也就是如下：

class InnerClass {
    static void main(args) {
        new InnerClass().printString()
        new InnerClass().printInt()

        //new InnerClass().printSelf();
    }

    public void printString(String name ) {
        println(name)
    }

    public void printInt(int age) {
        println(age)
    }

    public void printSelf(InnerClass innerClass) {
        innerClass.printInt(20)
    }

}

报错信息：
Exception in thread "main" groovy.lang.MissingMethodException: No signature of method: groovy.InnerClass.printInt() is applicable for argument types: () values: []
如上的调用规则(有一个参数但是调用是不传参数)也是用与构造函数。所以如果new X()来代替new X(this)会引发危险问题，例如空指针(就如上段代码注释掉的部分，如果打开注释，把printInt方法的参数改为Integer类型，那么执行到printSelf的时候由于方法参数innerClass在方法内部默认为null，就会引发NPE:Exception in thread "main" java.lang.NullPointerException: Cannot invoke method printInt() on null object),虽然这么使用语法上是规则的但是Groovy还没有找到阻止这么调用的办法。

7. 拉姆达表达式(Lambdas)

Java 8 开始支持Lambdas和方法引用：

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

Java 8拉姆达表达式可以认为是匿名的内部类。但是Groovy不支持这种语法，而是使用闭包代替：

Runnable run = { println 'run' }
list.each { println it } 或者 list.each(this.&println)

8. GStrings

双引号字符值被称为GString，如果一个类的字符串中包含美元符号，那么在使用Groovy或者Java编译器编译的时候Groovy会发生编译错误或者产生不同的代码。
当然，Groovy会在声明参数类型的API中自将GString和String值自动转换，就行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

println('c'.getClass())
println("c".getClass())
println('cc'.getClass())
println("cc".getClass())
println('c${1}'.getClass())
println("c${1}".getClass())

println输出结果为

class java.lang.String
class java.lang.String
class java.lang.String
class java.lang.String
class java.lang.String
class org.codehaus.groovy.runtime.GStringImpl

Groovy将自动转换只有一个字符的String为char，当这个把这个值赋值给声明为char类型的变量时。当调用参数类型是char类型的方法时，要么需要明确的类型转换，要么确保值已经被提前转换。
如下Character.digit(char,int)方法的参数类型是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风格的转换则报错
Groovy supports two styles of casting and in the case of casting to char there are subtle differences when casting a multi-char strings. The Groovy style cast is more lenient and will take the first character, while the C-style cast will fail with exception.

// 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. 原生类和包装类(Primitives and wrappers)

在Groovy中一切皆对象,会自动包装引用到原始类型。因为此，Groovy不遵循Java中的规范：类型提升优先于装箱。如下的例子：
先看java语法的：

public class Primitive {
    public static void main(String[] args) {
        int i = 5;
        m(i);
    }
   static void m(long l) {
        System.out.println("in m(long)");
    }
    static void m(Integer i) {
        System.out.println("in m(Integer)");
    }
}

或者把上边的m方法改为非静态的，调用的地方也改成实例方法调用

public class Primitive {
    public static void main(String[] args) {
        int i = 5;
        new Primitive().m(i);
    }
   void m(long l) {
        System.out.println("in m(long)");
    }
   void m(Integer i) {
        System.out.println("in m(Integer)");
    }
}

不管是静态的还是非静态的，以内Java中类型自动提升优先级高于装箱，所以输出结果都是in m(long)

如果在第一种的访问方式中(静态访问)，如果把Integer类型参数的m方法保持static，long类型参数的m方法改为非静态的，也就是把static去掉，或者两个方法都去掉static，在编译期间就会报错，
Error:(24, 9) java: 对m的引用不明确 main.java.Primitive 中的方法 m(long) 和 main.java.Primitive 中的方法 m(java.lang.Integer) 都匹配
而如果把Integer参数类型的m方法改为非静态的，也就是去掉static，long类型参数的m方法保持static，则可以正常调用，输出结果仍然是in m(long)
如果在第二种的访问方式中(实例方法访问)，不管m方法如何改，也就是不管是两个都是静态的还是两个都是非静态的还是一个静态一个非静态，最终都会调用long类型参数的m方法，输出结果都是in m(long)

都验证了类型提升优先级大于装箱。

再看Groovy语法：

class PrimitiveGroovy {
    static void main(args) {
        int i = 5;
        m(i)
    }
    static void m(long l) {
        System.out.println("in m(long)");
    }
    static void m(Integer i) {
        System.out.println("in m(Integer)");
    }   
}