Groovy 概述
Groovy是一种基于Java平台的面向对象语言。 Groovy 1.0于2007年1月2日发布，其中Groovy 2.4是当前的主要版本。 Groovy通过Apache License v 2.0发布。
Groovy的特点
Groovy中有以下特点:
- 同时支持静态和动态类型。
- 支持运算符重载。
- 本地语法列表和关联数组。
- 对正则表达式的本地支持。
- 各种标记语言，如XML和HTML原生支持。
- Groovy对于Java开发人员来说很简单，因为Java和Groovy的语法非常相似。
- 您可以使用现有的Java库。
- Groovy扩展了java.lang.Object。
Groovy的官方网站是http://www.groovy-lang.org/
Groovy 环境
有多种方式来获得的Groovy环境设置。
下载和安装 -进入该链接www.groovy-lang.org/download.html获得Windows安装程序部分。
启动Groovy安装程序，然后请执行以下完成安装步骤。
第1步 -选择语言安装程序。
第2步 -点击下一步按钮。
第3步 -点击“我同意”按钮。
第4步 -接受默认组件，然后单击下一步按钮。
第5步 -选择适当的目标文件夹，然后单击下一步按钮。
第6步 -点击安装按钮开始安装。
第7步 -一旦安装完成后，单击下一步按钮开始配置。
第8步 -选择默认选项，并单击下一步按钮。
第9步 -接受默认的文件关联，然后单击下一步按钮。
第10步 -单击Finish按钮完成安装。
一旦上述步骤之后，你就可以开始使用Groovy shell，有助于测试我们的Groovy，而不需要为Groovy提供一个完整的集成开发环境。可以通过在命令提示符下命令groovysh来完成。
Gradle
'org.codehaus.groovy:groovy:2.4.5'
Maven
<groupId>org.codehaus.groovy</groupId> <artifactId>groovy</artifactId> <version>2.4.5</version>
Groovy 基本语法
为了了解Groovy的基本语法，让我们先看看一个简单的Hello World程序。
创建你的第一个Hello World程序
创建Hello World程序，你只要输入以下几行简单的代码就可实现 -
class Example {
static void main(String[] args) {
// Using a simple println statement to print output to the console
println('Hello World');
}
}
当我们运行上面的程序，我们会得到以下结果 -
Hello World
在Groovy中导入语句
import语句可以用来导入，可以在你的代码可以使用其他库的功能。这是通过使用在 Import 关键字完成。
下面的示例演示了如何使用MarkupBuilder的类，它可能是最常用的创建HTML或XML标记的类之一。
import groovy.xml.MarkupBuilder def xml = new MarkupBuilder()
默认情况下，Groovy在代码中包括以下库，因此您不需要显式导入它们。
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令牌
令牌可以是一个关键字，一个标识符，常量，字符串文字或符号。
println(“Hello World”);
在上面的代码行中，有两个令牌，首先是关键词的println而接下来就是字符串的“Hello World”。
Groovy评论
在您的代码中使用注释。Groovy的注释可以是单行或多行。
单行注释使用//在该行的任何位置来识别。一个例子如下所示 -
class Example {
static void main(String[] args) {
// Using a simple println statement to print output to the console
println('Hello World');
}
}
多行注释标识与在开始/ *和* /识别多行注释的末尾。
class Example {
static void main(String[] args) {
/* This program is the first program
This program shows how to display hello world */
println('Hello World');
}
}
分号
就像Java编程语言，它需要具有分号在Groovy定义多个语句之间进行区分。
class Example {
static void main(String[] args) {
// One can see the use of a semi-colon after each statement
def x = 5;
println('Hello World');
}
}
上述例子示出了分号使用了不同行的代码语句之间进行区分。
身份标识
标识符被用来定义变量，函数或其他用户定义的变量。标识符以字母开头，美元或下划线。他们不能以数字开头。以下是有效标识符的一些例子
def employeename def student1 def student_name
其中，DEF是在Groovy用来定义标识符的关键字。
下面是一个如何在我们的Hello World程序中使用标识符的代码示例。
class Example {
static void main(String[] args) {
// One can see the use of a semi-colon after each statement
def x = 5;
println('Hello World');
}
}
在上述的例子中，变量x被用作标识符。
关键词
| 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和Groovy用来形容空格，制表符，换行符和注释术语。空格分隔从另一个声明的一部分，使编译器，其中一个元素标识的声明。
例如，在下面的代码示例，存在关键字def和变量x之间的空白。这是为了让编译器知道DEF是需要被使用，并且是x应该是需要被定义的变量名的关键字。
def x = 5;
文字
文字是在groovy中表示固定值的符号。Groovy语言有符号整数，浮点数，字符和字符串。下面是一些在Groovy编程语言文字的例子 -
12 1.45 ‘a’ “aa”
Groovy 数据类型
在任何编程语言中，需要使用各种变量来存储各种类型的信息。变量只是保留值的存储位置,这意味着，当你创建一个变量，你保留在内存中的一些空间来存储与变量相关的值。
您可能喜欢存储各种数据类型的信息，如字符串，字符，宽字符，整数，浮点数，布尔值等。基于变量的数据类型，操作系统分配内存并决定什么可以存储在保留的存储器中。
内置数据类型
Groovy提供多种内置数据类型。以下是在Groovy中定义的数据类型的列表 -
-
byte -这是用来表示字节值。例如2。
-
short -这是用来表示一个短整型。例如10。
-
int -这是用来表示整数。例如1234。
-
long -这是用来表示一个长整型。例如10000090。
-
float -这是用来表示32位浮点数。例如12.34。
-
double -这是用来表示64位浮点数，这些数字是有时可能需要的更长的十进制数表示。例如12.3456565。
-
char -这定义了单个字符文字。例如“A”。
-
Boolean -这表示一个布尔值，可以是true或false。
-
String -这些是以字符串的形式表示的文本。例如，“Hello World”的。
绑定值
下表显示了数字和小数点文字中的最大允许值。
| byte | -128到127 |
| short | -32,768到32,767 |
| int | 2,147,483,648 到,147,483,647 |
| long | -9,223,372,036,854,775,808到+9,223,372,036,854,775,807 |
| float | 1.40129846432481707e-45到3.40282346638528860e + 38 |
| double | 4.94065645841246544e-324d 到1.79769313486231570e + 308d |
数字类
类型除了基本类型，还允许以下对象类型（有时称为包装器类型）-
- java.lang.Byte
- java.lang.Short
- java.lang.Integer
- java.lang.Long
- java.lang.Float
- java.lang.Double
此外，以下类可用于支持高精度计算 -
| 名称 | 描述 | 例如 |
|---|---|---|
| java.math.BigInteger | 不可变的任意精度的有符号整数数字 | 30克 |
| java.math.BigDecimal | 不可变的任意精度的有符号十进制数 | 3.5克 |
以下代码示例说明如何使用不同的内置数据类型 -
class Example {
static void main(String[] args) {
//Example of a int datatype
int x = 5;
//Example of a long datatype
long y = 100L;
//Example of a floating point datatype
float a = 10.56f;
//Example of a double datatype
double b = 10.5e40;
//Example of a BigInteger datatype
BigInteger bi = 30g;
//Example of a BigDecimal datatype
BigDecimal bd = 3.5g;
println(x);
println(y);
println(a);
println(b);
println(bi);
println(bd);
}
}
当我们运行上面的程序，我们会得到以下结果 -
5 100 10.56 1.05E41 30 3.5
Groovy 变量
Groovy中的变量可以通过两种方式定义 - 使用数据类型的本地语法，或者使用def关键字。对于变量定义，必须明确提供类型名称或在替换中使用“def”。这是Groovy解析器需要的。
Groovy中有以下基本类型的变量，如上一章所述 -
-
byte - 这用于表示字节值。例如2。
-
short - 用于表示一个短数。例如10。
-
int - 这用于表示整数。 例如1234。
-
long - 这用于表示一个长数。例如10000090。
-
float - 用于表示32位浮点数。例如12.34。
-
double - 这用于表示64位浮点数。例如12.3456565。
-
char - 这定义了单个字符文字。例如'a'。
-
Boolean - 这表示一个布尔值，可以是true或false。
-
String - 这是以字符串形式表示的文本。 例如“Hello World”。
Groovy还允许其他类型的变量，如数组，结构和类，我们将在后续章节中看到。
变量声明
变量声明告诉编译器为变量创建存储的位置和大小。
下面是一个变量声明的例子 -
class Example {
static void main(String[] args) {
// x is defined as a variable
String x = "Hello";
// The value of the variable is printed to the console
println(x);
}
}
当我们运行上面的程序，我们会得到以下结果 -
Hello
变量命名
变量的名称可以由字母，数字和下划线字符组成。 它必须以字母或下划线开头。 大写和小写字母是不同的，因为Groovy，就像Java是一种区分大小写的编程语言。
class Example {
static void main(String[] args) {
// Defining a variable in lowercase
int x = 5;
// Defining a variable in uppercase
int X = 6;
// Defining a variable with the underscore in it's name
def _Name = "Joe";
println(x);
println(X);
println(_Name);
}
}
当我们运行上面的程序，我们会得到以下结果 -
5 6 Joe
我们可以看到x和X是两个不同的变量，因为区分大小写，在第三种情况下，我们可以看到_Name以下划线开头。
打印变量
您可以使用println函数打印变量的当前值。下面的示例显示了如何实现这一点。
class Example {
static void main(String[] args) {
//Initializing 2 variables
int x = 5;
int X = 6;
//Printing the value of the variables to the console
println("The value of x is " + x + "The value of X is " + X);
}
}
当我们运行上面的程序，我们会得到以下结果 -
The value of x is 5 The value of X is 6
Groovy 运算符
运算符是一个符号，通知编译器执行特定的数学或逻辑操作。
Groovy中有以下类型的运算符 -
- 算术运算符
- 关系运算符
- 逻辑运算符
- 位运算符
- 赋值运算符
算术运算符
Groovy语言支持正常的算术运算符任何语言。以下是在Groovy中可用的算术运算符 -
| 运算符 | 描述 | 例子 |
| + | 两个操作数的加法 | 1 + 2 将得到 3 |
| - | 第一第二操作数相减 |
2 - 1 将得到 1 |
| * | 两个操作数的乘法 | 2 * 2 将得到4 |
| / | 两个操作数的除法 | 3/2 将得到 1.5 |
| ％ | 取模运算 | 3％2 将得到 1 |
| ++ | 自增运算，在自身值的基础上加1 |
INT X = 5; X ++; X 将得到 6 |
| -- | 自减运算,在自身值的基础上减1 |
INT X = 5; X - -; X 将得到 4 |
关系运算符
关系运算符允许对象的比较。以下是在Groovy中可用的关系运算符 -| 运算符 | 描述 | 例子 |
|---|---|---|
| == | 测试两个对象之间是否相等 | 2 == 2 将得到 true |
| != | 测试两个对象之间是否不等 | 3 != 2 将得到 true |
| < | 检查是否左边的对象是小于右边的对象。 | 2 < 3 将得到 true |
| <= | 检查是否向左对象是小于或等于右边的对象 | 2 <= 3 将得到 true |
| > | 检查是否左边的对象比右边的对象大。 | 3 > 2 将得到 true |
| >= | 检查是否向左对象大于或等于右边的对象。 | 3>= 2 将得到 true |
逻辑运算符
逻辑运算符用于计算布尔表达式。以下是在Groovy中提供的逻辑运算符 -
| 运算符 | 描述 | 例子 |
|---|---|---|
| && | 这是逻辑“与”运算 | true && true 得到 true |
| || | 这是逻辑“或”运算 | true || true 得到 true |
| ！ | 这是逻辑“非”运算 | !true 得到 false |
位运算符
Groovy中提供了四个位运算符。以下是在Groovy中可用的位运算符 -
| 运算符 | 描述 |
|---|---|
| ＆ | 这是位“与”运算 |
| | | 这是按位“或”运算 |
| ^ | 这是按位“异或”或异或运算符 |
| 〜 | 这是按位反运算符 |
这里是显示这些运算符的真值表。
| p | q | p＆Q | p | q | p ^ Q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
赋值运算符
Groovy语言也提供了赋值操作符。以下是在Groovy提供的赋值运算符 -
| 运算符 | 描述 | 例子 |
|---|---|---|
| += | A += B 等价于 A = A+B |
DEF A = 5 A += 3 输出将是8 |
| -= | A -= B 等价于 A = A-B |
DEF A = 5 A -= 3 输出将是2 |
| *= | A *= B 等价于 A= A*B |
DEF A = 5 A *= 3 输出将是15 |
| /= | A /= B 等价于 A = A/B |
DEF A = 6 A /= 3 输出将是2 |
| (%)= | A (%)= B 等价于 A = A % B |
DEF A = 5 A %= 3 输出将是2 |
范围运算符
Groovy支持范围的概念，并在..符号的帮助下提供范围运算符的符号。下面给出了范围运算符的一个简单示例。
def range = 0..5
这只是定义了一个简单的整数范围，存储到一个局部变量称为范围内的下限为0和上限为5。
以下代码段显示了如何使用各种运算符。
class Example {
static void main(String[] args) {
def range = 5..10;
println(range);
println(range.get(2));
}
}
当我们运行上面的程序，我们会得到以下结果 -
从println语句中，可以看到显示在range语句中定义的整个数字范围。
get语句用于从定义的范围中获取一个对象，它将索引值作为参数。
[5, 6, 7, 8, 9, 10] 7
运算符优先级
下表按优先级顺序列出了所有groovy运算符
| 运算符 | 名称 |
|---|---|
| ++ - + - | 预增/减，一元加，一元减 |
| * / ％ | 乘法，除法，取模 |
| + - | 加法，减法 |
| ==！= <=> | 等于，不等于，比较 |
| ＆ | 二进制/位运算符与 |
| ^ | 二进制/位异或 |
| | | 二进制/按位或 |
| && | 逻辑和 |
| || | 逻辑或 |
| = ** = * = / =％= + = - = << = >> = >>> = = ^ = | = | 各种赋值运算符 |
Groovy 循环
到目前为止，我们已经看到已经按顺序方式一个接一个执行的语句。此外，在Groovy中提供了语句来改变程序逻辑中的控制流。然后将它们分类为我们将详细看到的控制语句的流程。
| 序号 | 语句和描述 |
|---|---|
| 1 | while语句
while语句首先通过计算条件表达式（布尔值）来执行，如果结果为真，则执行while循环中的语句。 |
| 2 | for语句
for语句用于遍历一组值。 |
| 3 | for-in语句
for-in语句用于遍历一组值。 |
循环控制语句
| 序号 | 语句和描述 |
|---|---|
| 1 | break语句
break语句用于改变循环和switch语句内的控制流。 |
| 2 | continue语句
continue语句补充了break语句。它的使用仅限于while和for循环。 |
Groovy If语句
第一个决策语句是 if 语句。这种说法的一般形式是 -
if(condition) {
statement #1
statement #2
...
}
这个语句的一般工作是首先在 if 语句中评估一个条件。如果条件为真，它然后执行语句。下图显示了 if 语句的流程。
下面是一个if / else语句的例子 -
class Example {
static void main(String[] args) {
// Initializing a local variable
int a = 2
//Check for the boolean condition
if (a<100) {
//If the condition is true print the following statement
println("The value is less than 100");
}
}
}
在上面的例子中，我们首先将一个变量初始化为值2.然后我们评估变量的值，然后决定是否应该执行 println 语句。上面的代码的输出将是 -
The value is less than 100
Groovy If/Else语句
我们将看到的下一个决策语句是 if / else 语句。这种说法的一般形式是 -
if(condition) {
statement #1
statement #2
...
} else{
statement #3
statement #4
}
这个语句的一般工作是首先在 if 语句中评估一个条件。如果条件为真，则其后执行语句，并在else条件之前停止并退出循环。如果条件为假，则执行else语句块中的语句，然后退出循环。下图显示了 if 语句的流程。
下面是一个if / else语句的例子 -
class Example {
static void main(String[] args) {
// Initializing a local variable
int a = 2
//Check for the boolean condition
if (a<100) {
//If the condition is true print the following statement
println("The value is less than 100");
} else {
//If the condition is false print the following statement
println("The value is greater than 100");
}
}
}
在上面的例子中，我们首先将一个变量初始化为值2.然后我们评估变量的值，然后决定应该执行哪个 println 语句。上面的代码的输出将是
The value is less than 100.
Groovy 嵌套If语句
有时需要有多个if语句嵌入在彼此内部。
这种说法的一般形式是 -
if(condition) {
statement #1
statement #2
...
} else if(condition) {
statement #3
statement #4
} else {
statement #5
statement #6
}
以下是嵌套if / else语句的示例 -
class Example {
static void main(String[] args) {
// Initializing a local variable
int a = 12
//Check for the boolean condition
if (a>100) {
//If the condition is true print the following statement
println("The value is less than 100");
} else
// Check if the value of a is greater than 5
if (a>5) {
//If the condition is true print the following statement
println("The value is greater than 5 and greater than 100");
} else {
//If the condition is false print the following statement
println("The value of a is less than 5");
}
}
}
在上面的例子中，我们首先将一个变量初始化为值12.在第一个 if 语句中，我们看到 a 的值是否大于100。如果没有，那么我们进入第二个for循环，看看 a 的值是否大于5或小于5.上面的代码的输出将是 -
The value is greater than 5 and greater than 100
Groovy Switch语句
有时，嵌套的if-else语句是如此常见，并且经常使用，以便设计一个更容易的语句，称为 switch 语句。
switch(expression) {
case expression #1:
statement #1
...
case expression #2:
statement #2
...
case expression #N:
statement #N
...
default:
statement #Default
...
}
本声明的一般工作如下 -
-
要评估的表达式放在switch语句中。
-
将有多个case表达式被定义以基于表达式的计算来决定应该执行哪一组语句。
-
在结尾处的语句的每个案例段中添加一个 break 语句。这是为了确保在执行相关语句集时立即退出循环。
-
还有一个默认case 语句，如果没有任何前面的情况表达式求值为true，则执行。
下图显示了 switch-case 语句的流程。
以下是switch语句的示例 -
class Example {
static void main(String[] args) {
//initializing a local variable
int a = 2
//Evaluating the expression value
switch(a) {
//There is case statement defined for 4 cases
// Each case statement section has a break condition to exit the loop
case 1:
println("The value of a is One");
break;
case 2:
println("The value of a is Two");
break;
case 3:
println("The value of a is Three");
break;
case 4:
println("The value of a is Four");
break;
default:
println("The value is unknown");
break;
}
}
}
在上面的例子中，我们首先将一个变量初始化为值2.然后我们有一个switch语句，它计算变量a的值。 基于变量的值，它将执行语句的相关案例集。上面的代码的输出将是 -
The value of a is Two
Groovy 嵌套Switch语句
它也可以有一个嵌套的 switch 语句。语句的一般形式如下所示 -
switch(expression) {
case expression #1:
statement #1
...
case expression #2:
statement #2
...
case expression #N:
statement #N
...
default:
statement #Default
...
}
下面是嵌套switch语句的一个示例 -
class Example {
static void main(String[] args) {
//Initializing 2 variables i and j
int i = 0;
int j = 1;
// First evaluating the value of variable i
switch(i) {
case 0:
// Next evaluating the value of variable j
switch(j) {
case 0:
println("i is 0, j is 0");
break;
case 1:
println("i is 0, j is 1");
break;
// The default condition for the inner switch statement
default:
println("nested default case!!");
}
break;
// The default condition for the outer switch statement
default:
println("No matching case found!!");
}
}
}
在上面的例子中，我们首先将a的变量初始化为a的值为2.然后我们有一个 switch 语句，它计算变量 a 的值。 基于变量的值，它将执行语句的相关案例集。上面的代码的输出将是 -
i is 0, j is 1
Groovy 方法
Groovy中的方法是使用返回类型或使用def关键字定义的。方法可以接收任意数量的参数。定义参数时，不必显式定义类型。可以添加修饰符，如public，private和protected。默认情况下，如果未提供可见性修饰符，则该方法为public。
最简单的方法是没有参数的方法，如下所示：
def methodName() {
//Method code
}
下面是一个简单方法的例子
class Example {
static def DisplayName() {
println("This is how methods work in groovy");
println("This is an example of a simple method");
}
static void main(String[] args) {
DisplayName();
}
}
在上面的例子中，DisplayName是一个简单的方法，它由两个println语句组成，用于向控制台输出一些文本。在我们的静态main方法中，我们只是调用DisplayName方法。上述方法的输出将是
-
This is how methods work in groovy This is an example of a simple method
方法参数
如果一个方法的行为由一个或多个参数的值确定，则它通常是有用的。我们可以使用方法参数将值传递给被调用的方法。请注意，参数名称必须彼此不同。
使用参数的最简单的方法类型，如下所示 −
def methodName(parameter1, parameter2, parameter3) {
// Method code goes here
}
以下是使用参数的简单方法的示例
class Example {
static void sum(int a,int b) {
int c = a+b;
println(c);
}
static void main(String[] args) {
sum(10,5);
}
}
在这个例子中，我们创建一个带有2个参数a和b的sum方法。两个参数都是int类型。然后我们从我们的main方法中调用sum方法，并将值传递给变量a和b。
然后我们从我们的main方法中调用sum方法，并将值传递给变量a和b。上述方法的输出将是值15。
默认参数
Groovy中还有一个规定来指定方法中的参数的默认值。 如果没有值传递给参数的方法，则使用缺省值。 如果使用非默认和默认参数，则必须注意，默认参数应在参数列表的末尾定义。
以下是使用参数的简单方法的示例 -
def someMethod(parameter1, parameter2 = 0, parameter3 = 0) {
// Method code goes here
}
让我们看看我们之前看到的添加两个数字的相同示例，并创建一个具有一个默认和另一个非默认参数的方法
-
class Example {
static void sum(int a,int b = 5) {
int c = a+b;
println(c);
}
static void main(String[] args) {
sum(6);
}
}
在这个例子中，我们创建一个具有两个参数a和b的sum方法。两个参数都是int类型。此示例和上一个示例的区别在于，在这种情况下，我们将b的默认值指定为5。因此，当我们从main方法中调用sum方法时，我们可以选择只传递一个值为6的值，并将其分配给sum方法中的参数a。
上述方法的输出将为值11。
class Example {
static void sum(int a,int b = 5) {
int c = a+b;
println(c);
}
static void main(String[] args) {
sum(6,6);
}
}
我们也可以通过传递2个值来调用sum方法，在上面的例子中，我们传递2个值6.第二个值6实际上将替换分配给参数b的默认值。上述方法的输出将是值12。
方法返回值
方法也可以将值返回到调用程序。 这在现在编程语言中是必需的，其中方法执行某种计算，然后将所需值返回到调用方法。下面是一个带有返回值的简单方法的例子。
class Example {
static void sum(int a,int b = 5) {
int c = a+b;
return c;
}
static void main(String[] args) {
println(sum(6));
}
}
在我们上面的例子中，注意这次我们为我们的方法sum指定一个类型为int的返回类型。
在方法中，我们使用return语句将sum值发送到调用主程序。 由于方法的值现在可用于main方法，因此我们使用println函数在控制台中显示该值。在前面的例子中，我们将我们的方法定义为静态方法，这意味着我们可以直接从类中访问这些方法。方法的下一个示例是实例方法，其中通过创建类的对象来访问方法。我们将在后面的章节中看到类，现在我们将演示如何使用方法。上述方法的输出将为值11。
实例方法
方法通常在Groovy中的类中实现，就像Java语言一样。类只是一个蓝图或模板，用于创建定义其属性和行为的不同对象。类对象显示由其类定义的属性和行为。因此，通过在类中创建方法来定义行为。
我们将在后面的章节中更详细地看到类，下面是类中方法实现的例子。以下是如何实现方法的示例。
class Example {
int x;
public int getX() {
return x;
}
public void setX(int pX) {
x = pX;
}
static void main(String[] args) {
Example ex = new Example();
ex.setX(100);
println(ex.getX());
}
}
在我们上面的例子中，这次我们没有为类方法指定静态属性。在我们的main函数中，我们实际上创建了一个Example类的实例，然后调用'ex'对象的方法。上述方法的输出将是值100。
本地和外部参数名称
Groovy提供的设施就像java一样具有本地和全局参数。在下面的示例中，lx是一个局部参数，它只具有getX（）函数内的作用域，x是一个全局属性，可以在整个Example类中访问。如果我们尝试访问getX（）函数之外的变量lx，我们将得到一个错误。
class Example {
static int x = 100;
public static int getX() {
int lx = 200;
println(lx);
return x;
}
static void main(String[] args) {
println getX()
}
}
当我们运行上面的程序，我们会得到以下结果。
200 100
方法属性
就像在Java中一样，groovy可以使用this关键字访问它的实例成员。以下示例显示了当我们使用语句this.x时，它引用其实例并相应地设置x的值。
class Example {
int x = 100;
public int getX() {
this.x = 200;
return x;
}
static void main(String[] args) {
Example ex = new Example();
println(ex.getX());
}
}
当我们运行上面的程序，我们将得到200的结果打印在控制台上。
Groovy 文件I/O
Groovy在使用I / O时提供了许多辅助方法，Groovy提供了更简单的类来为文件提供以下功能。
- 读取文件
- 写入文件
- 遍历文件树
- 读取和写入数据对象到文件
除此之外，您始终可以使用下面列出的用于文件I / O操作的标准Java类。
- java.io.File
- java.io.InputStream
- java.io.OutputStream
- java.io.Reader
- java.io.Writer
读取文件
以下示例将输出Groovy中的文本文件的所有行。方法eachLine内置在Groovy中的File类中，目的是确保文本文件的每一行都被读取。
import java.io.File
class Example {
static void main(String[] args) {
new File("E:/Example.txt").eachLine {
line -> println "line : $line";
}
}
}
File类用于实例化以文件名作为参数的新对象。 然后它接受eachLine的函数，将它放到一个line的变量并相应地打印它。如果文件包含以下行，它们将被打印。
line : Example1 line : Example2
读取文件的内容到字符串
如果要将文件的整个内容作为字符串获取，可以使用文件类的text属性。以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
File file = new File("E:/Example.txt")
println file.text
}
}
如果该文件包含以下行，它们将被打印出来。
line : Example1 line : Example2
写入文件
如果你想写入文件，你需要使用作家类输出文本到一个文件中。下面的例子说明了如何可以做到这一点。
import java.io.File
class Example {
static void main(String[] args) {
new File('E:/','Example.txt').withWriter('utf-8') {
writer -> writer.writeLine 'Hello World'
}
}
}
如果你打开文件example.txt文件，您将看到文本中打印了“Hello World”这个词。
获取文件的大小
如果要获取文件的大小，可以使用文件类的length属性来获取，以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
File file = new File("E:/Example.txt")
println "The file ${file.absolutePath} has ${file.length()} bytes"
}
}
上面的代码将显示文件的大小（以字节为单位）。
测试文件是否是目录
如果要查看路径是文件还是目录，可以使用File类的isFile和isDirectory选项。以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
def file = new File('E:/')
println "File? ${file.isFile()}"
println "Directory? ${file.isDirectory()}"
}
}
上面的代码将显示以下输出 -
File? false Directory? True
创建目录
如果要创建一个新目录，可以使用File类的mkdir函数。以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
def file = new File('E:/Directory')
file.mkdir()
}
}
如果目录E： Directory不存在，将创建它。
删除文件
如果要删除文件，可以使用File类的delete功能。以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
def file = new File('E:/Example.txt')
file.delete()
}
}
如果存在该文件将被删除。
复制文件
Groovy还提供将内容从一个文件复制到另一个文件的功能。以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
def src = new File("E:/Example.txt")
def dst = new File("E:/Example1.txt")
dst << src.text
}
}
将创建文件Example1.txt，并将文件Example.txt的所有内容复制到此文件。
获取目录内容
Groovy还提供了列出驱动器中的驱动器和文件的功能。
以下示例显示如何使用File类的listRoots函数显示机器上的驱动器。
class Example {
static void main(String[] args) {
def rootFiles = new File("test").listRoots()
rootFiles.each {
file -> println file.absolutePath
}
}
}
根据机器上可用的驱动器，输出可能会有所不同。在标准机器上的输出将类似于下面的一个
-
C: D:
以下示例显示如何使用File类的eachFile函数列出特定目录中的文件。
class Example {
static void main(String[] args) {
new File("E:/Temp").eachFile() {
file->println file.getAbsolutePath()
}
}
}
输出将显示目录E： Temp中的所有文件
如果要递归显示目录及其子目录中的所有文件，则可以使用File类的eachFileRecurse函数。以下示例显示如何完成此操作。
class Example {
static void main(String[] args) {
new File("E:/temp").eachFileRecurse() {
file -> println file.getAbsolutePath()
}
}
}
输出将显示目录E： Temp中的所有文件及其子目录（如果存在）。
Groovy 可选
Groovy是一个“可选”类型的语言，当理解语言的基本原理时，这种区别是一个重要的语言。与Java相比，Java是一种“强”类型的语言，由此编译器知道每个变量的所有类型，并且可以在编译时理解和尊重合同。这意味着方法调用能够在编译时确定。
当在Groovy中编写代码时，开发人员可以灵活地提供类型或不是类型。这可以提供一些简单的实现，并且当正确利用时，可以以强大和动态的方式为您的应用程序提供服务。
在Groovy中，可选的键入是通过'def'关键字完成的。下面是一个使用def方法的例子
-
class Example {
static void main(String[] args) {
// Example of an Integer using def
def a = 100;
println(a);
// Example of an float using def
def b = 100.10;
println(b);
// Example of an Double using def
def c = 100.101;
println(c);
// Example of an String using def
def d = "HelloWorld";
println(d);
}
}
从上面的程序，我们可以看到，我们没有声明单个变量为Integer，float，double或string，即使它们包含这些类型的值。
当我们运行上面的程序，我们将得到以下结果 -
100 100.10 100.101 HelloWorld
可选的打字在开发期间可以是一个强大的实用程序，但是当代码变得太大和复杂时，可能导致在后期开发阶段的可维护性问题。
要了解如何使用Groovy中的可选输入，而不让代码库陷入无法维护的混乱，最好在应用程序中采用“鸭式输入”的理念。
如果我们使用鸭式重写上面的代码，它将看起来像下面给出的。变量名称的名称比它们代表的类型更多，这使得代码更容易理解。
class Example {
static void main(String[] args) {
// Example of an Integer using def
def aint = 100;
println(aint);
// Example of an float using def
def bfloat = 100.10;
println(bfloat);
// Example of an Double using def
def cDouble = 100.101;
println(cDouble);
// Example of an String using def
def dString = "HelloWorld";
println(dString);
}
}Groovy 数字
在Groovy中，数字实际上表示为对象，它们都是类Integer的一个实例。要使对象做某事，我们需要调用在其类中声明的一个方法。
Groovy支持整数和浮点数。
- 整数是不包含分数的值。
- 浮点数是包含小数部分的十进制值。
Groovy中的数字示例如下所示 -
Integer x = 5; Float y = 1.25;
其中x是整数类型，y是浮点数。
groovy中的数字被定义为对象的原因通常是因为存在对数字执行操作的要求。在原始类型上提供类的概念被称为包装类。
默认情况下，Groovy中提供了以下包装程序类。
包装类的对象包含或包装其各自的基本数据类型。将原始数据类型转换为对象的过程称为装箱，这由编译器负责。将对象转换回其对应的基本类型的过程称为取消装箱。
例子
以下是装箱和拆箱的例子 -
class Example {
static void main(String[] args) {
Integer x = 5,y = 10,z = 0;
// The the values of 5,10 and 0 are boxed into Integer types
// The values of x and y are unboxed and the addition is performed
z = x+y;
println(z);
}
}
上述程序的输出将为5.在上述示例中，5,10和0的值相应地首先嵌入到整数变量x，y和z中。上述程序的输出将是5。然后，当执行x和y的添加时，值从其整数类型取消装箱。
数字方法
由于Groovy中的Numbers表示为类，以下是可用的方法列表。
| 序号 | 方法和描述 |
|---|---|
| 1 | xxxValue（）
此方法接受Number作为参数，并基于调用的方法返回基本类型。 |
| 2 | compareTo()
compareTo方法是使用比较一个数字与另一个数字。如果要比较数字的值，这是有用的。 |
| 3 | equals()
该方法确定调用方法的Number对象是否等于作为参数传递的对象。 |
| 4 | valueOf()
valueOf方法返回保存所传递的参数的值的相关Number对象。 |
| 5 | toString()
该方法用于获取表示Number对象的值的String对象。 |
| 6 | parseInt()
此方法用于获取某个String的原始数据类型。 parseXxx（）是一个静态方法，可以有一个参数或两个参数。 |
| 7 | abs()
该方法给出了参数的绝对值。参数可以是int，float，long，double，short，byte。 |
| 8 | ceil()
方法ceil给出大于或等于参数的最小整数。 |
| 9 | floor()
方法floor给出小于或等于参数的最大整数。 |
| 10 | rint()
方法rint返回值最接近参数的整数。 |
| 11 | round()
方法round返回最接近的long或int，由方法返回类型给出。 |
| 12 | min()
该方法给出两个参数中较小的一个。参数可以是int，float，long，double。 |
| 13 | max()
该方法给出了两个参数的最大值。参数可以是int，float，long，double。 |
| 14 | exp()
该方法返回自然对数e的底数为参数的幂。 |
| 15 | log()
该方法返回参数的自然对数。 |
| 16 | pow()
该方法返回第一个参数的值增加到第二个参数的幂。 |
| 17 | sqrt()
该方法返回参数的平方根。 |
| 18 | sin()
该方法返回指定double值的正弦值。 |
| 19 | cos()
该方法返回指定double值的余弦值。 |
| 20 | tan()
该方法返回指定double值的正切值。 |
| 21 | asin()
该方法返回指定double值的反正弦值。 |
| 22 | acos()
该方法返回指定double值的反余弦值。 |
| 23 | atan()
该方法返回指定double值的反正切。 |
| 24 | atan2()
该方法将直角坐标（x，y）转换为极坐标（r，theta），并返回theta。 |
| 25 | parseInt（）
该方法将参数值转换为度。 |
| 26 | radian()
该方法将参数值转换为弧度。 |
| 27 | random()
该方法用于生成介于0.0和1.0之间的随机数。范围是：0.0 = <Math.random <1.0。通过使用算术可以实现不同的范围。 |
Groovy xxxValue()方法
此方法接受Number作为参数，并基于调用的方法返回基本类型。 以下是可用的方法列表 -
byte byteValue() short shortValue() int intValue() long longValue() float floatValue() double doubleValue()
参数 - 无需参数。
返回值 - 返回值是根据调用的值函数返回的原始类型。
例子
以下是方法值的用法示例。
class Example {
static void main(String[] args) {
Integer x = 5;
// Converting the number to double primitive type
println(x.doubleValue());
// Converting the number to byte primitive type
println(x.byteValue());
// Converting the number to float primitive type
println(x.floatValue());
// Converting the number to long primitive type
println(x.longValue());
// Converting the number to short primitive type
println(x.shortValue());
// Converting the number to int primitive type
println(x.intValue());
}
}
当我们运行上面的程序，我们将得到以下结果 -
5.0 5 5.0 5 5 5
Groovy compareTo()方法
compareTo方法是使用比较一个数字与另一个数字。如果要比较数字的值，这是有用的。
句法
public int compareTo( NumberSubClass referenceName )
参数
referenceName - 这可以是字节，双精度，整数，浮点型，长整型或短整型。
返回值
- 如果整数等于参数，则返回0。
- 如果整数小于参数，则返回-1。
- 如果整数大于参数，则返回1。
例子
下面是一个使用这个方法的例子 -
class Example {
static void main(String[] args) {
Integer x = 5;
//Comparison against a Integer of lower value
System.out.println(x.compareTo(3));
//Comparison against a Integer of equal value
System.out.println(x.compareTo(5));
//Comparison against a Integer of higher value
System.out.println(x.compareTo(8));
}
}
当我们运行上面的程序，我们将得到以下结果 -
1 0 -1
Groovy equals()方法
该方法确定调用方法的Number对象是否等于作为参数传递的对象。
句法
public boolean equals(Object o)
参数
o - 任何对象。
返回值
如果参数不为空，并且是同一类型且具有相同数值的对象，则方法返回True。
例子
下面是一个使用这个方法的例子 -
class Example {
static void main(String[] args) {
Integer x = 5;
Integer y = 10;
Integer z = 5;
//Comparison against an Integer of different value
System.out.println(x.equals(y));
//Comparison against an Integer of same value
System.out.println(x.equals(z));
}
}
当我们运行上面的程序，我们将得到以下结果 -
false true
--------------------------------------------------------------------------