groovy与java语法区别

Posted 唠叨叨

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了groovy与java语法区别相关的知识,希望对你有一定的参考价值。

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、。。








以上是关于groovy与java语法区别的主要内容,如果未能解决你的问题,请参考以下文章

Scala,Groovy,Clojure三门语言的区别

精通Groovy之简要总结

Groovy与Java集成常见的坑

GroovyGroovy 代码创建 ( 使用 Java 语法实现 Groovy 类和主函数并运行 | 按照 Groovy 语法改造上述 Java 语法规则代码 )

groovy 在eclipse中如何实现语法提示

Gradle入门之Groovy语法