Groovy<第二篇>：基础语法(1)

[在Groovy中导入语句]

一般情况下，如果使用某个API，需要使用import关键字引用对应的包，就拿MarkupBuilder类举例，它可能是最常用的创建HTML或XML标记的类之一。

图片.png

默认情况下，Groovy已经引用了如下API导包，可以不需要我们去刻意的导入如下包：

import java.lang.*
import java.util.*
import java.io.*
import java.net.*

import groovy.lang.*
import groovy.util.*

import java.math.BigInteger
import java.math.BigDecimal

[Groovy注释]

Groovy的注释和Java是一样的，分为文档注释、多行注释、单行注释。

/**
 * 文档注释
 * @param args
 */
public static void main(String[] args){


    /*  多行注释
    Object o = "Object";
    int result = method(o);
    */

    //当行注释
    //printf("result:"+result)

}

[分号]

Groovy和Java一样，都是使用" ;"作为语句的结束符号。
Groovy比较特殊，一个语法的结束可以不使用分号，用换行代替即可。

    println("Hello Word")
    println("Hello Word")
    println("Hello Word")
    println("Hello Word")
    println("Hello Word")
    println("Hello Word")

如上面的代码，可以不使用分号。

[变量的定义]

Java中，如果定义一个变量，必然使用基本数据类型（int,float,double,byte,char,long,short）和对象类型，如下：

    int a = 1;
    float b = 2.1f;
    double c = 3.1;
    String d = "4";
    MarkupBuilder xml;

Groovy可以使用弱类型def定义那些变量，如下：

    def a = 1;
    def b = 2.1f;
    def c = 3.1;
    def d = "4";
    def xml;

[关键字]

Groovy关键字有：

--	--	--	--
as	assert	break	case
catch	class	const	continue
def	default	do	else
enum	extends	false	Finally
for	goto	if	implements
import	in	instanceof	interface
new	pull	package	return
super	switch	this	throw
throws	trait	true	try
while

[自动装箱]

什么叫装箱？ Java中，将基本数据类型转换成对象的过程。（如int转换成Integer）

    byte a = 1;
    println(a.getClass().getName());

看一下上面这两句代码，在Java语言下，这代码会报错的，因为a是基本数据类型，不是对象，所以无法获取到Class。
在Groovy语言下，也支持基本数据类型的使用，但是，基本数据类型会被自动转换成对象，也就是自动装箱。

先来看下如下代码：

    byte a = 1
    println(a.getClass().getName())
    short b = 2
    println(b.getClass().getName())
    int c = 3
    println(c.getClass().getName())
    long d = 4L
    println(d.getClass().getName())
    float e = 5.1f
    println(e.getClass().getName())
    double f = 6.1
    println(f.getClass().getName())
    char g = 'z'
    println(g.getClass().getName())
    boolean h = false
    println(h.getClass().getName())
    String j = "字符串"
    println(j.getClass().getName())
    Hello hello = new Hello()
    println(hello.getClass().getName())

它们的打印结果如下：

    java.lang.Byte
    java.lang.Short
    java.lang.Integer
    java.lang.Long
    java.lang.Float
    java.lang.Double
    java.lang.Character
    java.lang.Boolean
    java.lang.String
    Hello

如果使用Groovy专属定义数据类型的def关键字，那么代码如下：

    def a = 1
    println(a.getClass().getName())
    def b = 2
    println(b.getClass().getName())
    def c = 3
    println(c.getClass().getName())
    def d = 4L
    println(d.getClass().getName())
    def e = 5.1f
    println(e.getClass().getName())
    def f = 6.1
    println(f.getClass().getName())
    def g = 'z'
    println(g.getClass().getName())
    def h = false
    println(h.getClass().getName())
    def j = "字符串"
    println(j.getClass().getName())
    def hello = new Hello()
    println(hello.getClass().getName())

它们的打印结果如下：

    java.lang.Integer
    java.lang.Integer
    java.lang.Integer
    java.lang.Long
    java.lang.Float
    java.math.BigDecimal
    java.lang.String
    java.lang.Boolean
    java.lang.String
    Hello

从打印结果的比较，很容易看出其中的区别。

[类型强转]

    double f = 6.1
    String j = "字符串"
    f = j

上面的三行代码我想大家都不陌生，第三句是不同类型数据的赋值，不同数据类型的赋值必须强壮，如果没有强转会报以下的错误

图片.png

在Groovy语言下，如果使用def关键字定义变量，那么就不需要考虑类型转换异常。

我们修改下代码：

    def f = 6.1
    def j = "字符串"
    f = j
    println(f+":"+f.getClass().getName())

修改代码后的打印结果如下：

图片.png

我们发现，使用弱类型def定义的变量根本不需要担心类型转换异常。

[变量区分大小写]

Groovy和Java一样，变量都区分大小写。

    def a = 1.1
    def A = "字符串"
    println a
    println A

打印结果如下:

图片.png

[字符串]

Groovy的字符串可以由单引号修饰，也可以由双引号修饰。如：

    def str1 = '单引号'
    def str2 = "双引号"

这里建议使用双引号，因为如果字符串中含有变量，那么这个字符串只能使用双引号修饰。

如：

    def name = "张三"
    println '${name}在上厕所'

以上代码的打印结果是：

${name}在上厕所

name变量没有生效，将单引号换成双引号之后，如下：

    def name = "张三"
    println "${name}在上厕所"

这样，打印结果就正常了

张三在上厕所

Groovy字符串有一个地方特别需要注意，即单引号和双引号都可以表示字符串。

println 'aaaa'

所以，如果定义一个字符

char a = 'a'

Groovy编译器也会认为是一个字符串，编译器会将char转换成String包装类型。

[本章完...]