.kt与.java还有.groovy_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、。。