groovy与java语法区别

Groovy试图对Java开发人员尽可能地兼容。在设计Groovy时，遵循最不意外的原则，尤其是对于那些来自Java背景的开发人员。

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

1.额外的关键字

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

as
def
in
trait

2.数组初始化

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

// java初始化
int[] array = { 1, 2, 3}
// groovy初始化必须使用方括号
int[] array = [1,2,3]

3.基本类型和包装类

因为Groovy将Objects用于所有内容，所以它会自动对基本类型进行包装。因此，它不遵循Java的提升行为优先于自动装箱。这是一个使用int的例子

int i   // groovy 自动装箱
m(i)
// Java 会调用这个 基本类型提升优先于自动装箱
void m(long l) {
  println "in m(long)"
}
// groovy会调用这个 自动装箱了已经
void m(Integer i) {
  println "in m(Integer)"
}

4.==的行为

在Java中==表示基本类型或对象的标识的相等性。

在Groovy中== 如果它们是Comparable，转换为a.compareTo(b)== 0，否则转换为a.equals(b)

要检查一致，有is方法。例如a.is(b)中。

5.方法重载

在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中，=2
assertEquals(2, result);
//在Groovy中：=1
assertEquals(1, result);

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

6. GStrings

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

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

7. String and 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 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‘

8.默认导入

默认情况下导入所有这些包和类，即您不必使用显式import语句来使用它们：

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

9.包范围可见性

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

class Person {
    String name
}

相反，它用于创建属性，即私有字段，关联的getter和关联的setter。 可以通过使用@PackageScope注释来创建包私有字段：

class Person {
    @PackageScope String name
}

10.ARM块

Groovy不支持Java 7中的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
   }
}

11.内部类

匿名内部类和嵌套类的实现是Java引领的，但是您不应该排除Java语言规范纠结为什么不同。这些实现看起来很像我们为groovy.lang.Closure做的，有一些好处和一些差异。例如，访问私有字段和方法可能会成为一个问题，但另一方面，局部变量不一定是final的。

11.1 静态内部类

class A {
    // 静态内部类B
    static class B {}
}

new A.B()

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

11.2 匿名内部类

import java.util.concurrent.CountDownLatch
import java.util.concurrent.TimeUnit

CountDownLatch called = new CountDownLatch(1)

Timer timer = new Timer()
// 匿名内部类 实现了TimerTask接口
timer.schedule(new TimerTask() {
    void run() {
        called.countDown()
    }
}, 0)

assert called.await(10, TimeUnit.SECONDS)

11.3 创建非静态内部类的实例

public class Y {
    // 非静态内部类X
    public class X {}
    public X foo() {
        return new X();
    }
    public static X createX(Y y) {
        // 创建非静态内部类实例
        return y.new X();
    }
}

Groovy不支持y.new X（）语法。相反，您必须编写新的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。基本上相同的规则适用于调用构造函数。

例如，您可能会编写新的X（）而不是新的X（this）。由于这也可能是常规方式，我们尚未找到防止此问题的好方法。

12.Lambdas

Java 8支持lambda和方法引用：

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

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

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

12.转换

Java会自动扩展和缩小转换

基础类型 如byte、int、。。

原文地址：https://www.cnblogs.com/laodaodao/p/10102072.html