Groovy基础教程

一、概述

Groovy是一种基础JVM(Java虚拟机)的敏捷开发语言,他结合了Python、Ruby和Smalltalk的特性,Groovy代码能够于Java代码很好的结合,也能用于扩展现有代码。由于其运行在JVM的特性,Groovy可以使用其他Java语言编写法的库。

一个简单的打印例子,演示下Groovy和Java的差异

//java写法
class FuncITFeiniu{ 
    public static void mian(String[] args){ 
        println("Hello World!");
    }
}
//groovy写法 文件名:chapter01.groovy
println("Hello World!");

//执行
groovy chapter01.groovy
groovy chapter01

二、安装 - window10

1、下载

需要提到的是,groovy运行依赖JDK,所以我们需要先安装JDK再安装groovy

JDK下载地址:https://www.oracle.com/java/technologies/downloads/

groovy下载地址:http://www.groovy-lang.org/download.html

下载下来是这样的两个zip包,apache-groovy-sdk-4.0.12.zipjdk-20_windows-x64_bin.zip。如下图:

在这里插入图片描述

这里我们都选择的*.zip安装包,也可以选择msiexe自动化安装。

2、配置环境变量

将上述两个包解压,然后我们打开【环境变量】。
Groovy基础教程_第1张图片

  1. 配置JAVA_HOME系统变量
    Groovy基础教程_第2张图片

  2. PATH中,添加JDK命令行,%JAVA_HOME%\bin

  3. PATH中,添加groovy命令行,C:\Program Files\groovy-4.0.12\bin
    Groovy基础教程_第3张图片

到这里就已经安装完成,我们打开cmd命令行工具,验证下是否安装成功,分别输入java -versiongroovy -version,看看是否能否正常打印版本号,如果正常打印,安装就已经成功。
Groovy基础教程_第4张图片

三、默认引入

默认情况下,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

四、数据类型

1、内置数据类型

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 -2^7 ~ +2^7
short -32,768到32,767 -2^15 ~ +2^15
int -2,147,483,648到2,147,483,647 -2^31 ~ +2^31
long -9,223,372,036,854,775,808到+9,223,372,036,854,775,807 -2^63 ~ +2^63
float 1.40129846432481707e-45到3.40282346638528860e + 38 -2^127 ~ +2^127
double 4.94065645841246544e-324d 到1.79769313486231570e + 308d -2^255 ~ +2^255
class Example { 
   static void main(String[] args) { 
      //整型 
      int x = 5; 
      //长整型 
      long y = 100L; 
		
      //单精度型 
      float a = 10.56f; 
		
      //双精度型 
      double b = 10.5e40; 
		
      //不可变的任意精度的有符号整数数字
      BigInteger bi = 30g; 
		
      //不可变的任意精度的有符号十进制数
      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

2、动态变量

如果是使用内置变量类型定义的变量,一经定义,后面是不可以更改变量类型的。但是Groovy也提供了类似javascript中的any定义任意变量类型的关键字def

class Example { 
   static void main(String[] args) { 
      def _Name = 1;
      _Name="it飞牛"; 
      println(_Name);
   } 
}
//打印如下:
it飞牛

五、运算符

1、算术运算符

运算符 描述 例子
+ 两个操作数的加法 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

2、关系运算符

运算符 描述 例子
== 测试两个对象之间是否相等 2 == 2 将得到 true
!= 测试两个对象之间是否不等 3 != 2 将得到 true
< 检查是否左边的对象是小于右边的对象。 2 < 3 将得到 true
<= 检查是否向左对象是小于或等于右边的对象 2 <= 3 将得到 true
> 检查是否左边的对象比右边的对象大。 3 > 2 将得到 true
>= 检查是否向左对象大于或等于右边的对象。 3>= 2 将得到 true

3、逻辑运算符

运算符 描述 例子
&& 这是逻辑“与”运算 true && true 得到 true
|| 这是逻辑“或”运算 true || true 得到 true
这是逻辑“非”运算 !true 得到 false

4、位运算符

运算符 描述
这是位“与”运算
| 这是按位“或”运算
^ 这是按位“异或”或异或运算符
这是按位反运算符

5、赋值运算符

运算符 描述 例子
+= A += B 等价于 A = A+B DEF A = 5A += 3输出将是8
-= A -= B 等价于 A = A-B DEF A = 5A -= 3输出将是2
*= A = B 等价于 A= AB DEF A = 5A *= 3输出将是15
/= A /= B 等价于 A = A/B DEF A = 6A /= 3输出将是2
(%)= A (%)= B 等价于 A = A % B DEF A = 5A %= 3输出将是2

6、范围运算符

Groovy支持范围的概念,并在..符号的帮助下提供范围运算符的符号。

class Example { 
   static void main(String[] args) { 
      def range = 5..10; 
      println(range); 
      println(range.get(2)); 
   } 
}
//打印如下:
5..10
6
7
8
9
10

六、循环

1、while语句

class Example {
   static void main(String[] args) {
      int count = 0;
        
      while(count<5) {
         println(count);
         count++;
      }
   }
}

2、for语句

class Example { 
   static void main(String[] args) {
    
      for(int i = 0;i<5;i++) {
         println(i);
      }
        
   }
}

3、for-in语句

class Example { 
   static void main(String[] args) { 
      int[] array = [0,1,2,3]; 
        
      for(int i in array) { 
         println(i); 
      } 
   } 
}

4、循环控制语句

序号 语句和描述
1 break语句break语句用于改变循环和switch语句内的控制流。
2 continue语句continue语句补充了break语句。它的使用仅限于while和for循环。

七、条件语句

1、if语句

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、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"); 
      } 
   } 
}

3、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; 
      }
   }
}

八、方法

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();
   } 
}

参数和返回值

  • 支持传入多个,以,号分割,并配以类型关键字。
  • 支持设置默认值
  • 返回值可以是基础类型、def、void

案例1:

class Example {
   static int sum(int a,int b = 5) {
      int c = a+b;
      return c;
   } 
	
   static void main(String[] args) {
      println(sum(6));
   } 
}
//打印:
//11

案例2:

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

案例3:

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

九、文件I/O

Groovy在使用I / O时提供了许多辅助方法,Groovy提供了更简单的类来为文件提供以下功能。

  • 读取文件
  • 写入文件
  • 遍历文件树
  • 读取和写入数据对象到文件

除此之外,您始终可以使用下面列出的用于文件I / O操作的标准Java类。

  • java.io.File
  • java.io.InputStream
  • java.io.OutputStream
  • java.io.Reader
  • java.io.Writer

读取文件

import java.io.File 
class Example { 
   static void main(String[] args) { 
      new File("./Example.txt").eachLine {  
         line -> println "line : $line"; 
      } 
   } 
}
//同目录下存在Example.txt文件,内容如下:
line : Example1
line : Example2

//执行上述代码后,控制台打印如下:
line : line : Example1
line : line : Example2

读取文件的内容到字符串

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('./Example.txt').withWriter('utf-8') { 
         writer -> writer.writeLine 'Hello World' 
      }  
   } 
}
//执行后,Example.txt中的内容会被替换为:Hello World

获取文件的大小

class Example {
   static void main(String[] args) {
      File file = new File("E:/Example.txt")
      println "The file ${file.absolutePath} has ${file.length()} bytes"
   } 
}
//打印:
//The file D:\学习\groovy\Code\groovy-project\.\Example.txt has 13 bytes

测试文件是否是目录

class Example { 
   static void main(String[] args) { 
      def file = new File('./') 
      println "File? ${file.isFile()}" 
      println "Directory? ${file.isDirectory()}" 
   } 
}
//打印:
//File? false
//Directory? true

创建目录

class Example {
   static void main(String[] args) {
      def file = new File('./Directory')
      file.mkdir()
   } 
}
//执行完成后,会在当前目录下新建一个 Directory 目录

删除文件

class Example {
   static void main(String[] args) {
      def file = new File('./Example.txt')
      file.delete()
   } 
}
//执行完成后,会把当前目录下的./Example.txt文件删除

复制文件

class Example {
   static void main(String[] args) {
      def src = new File("./Example.txt")
      def dst = new File("./Example1.txt")
      dst << src.text
   } 
}
//将创建文件Example1.txt,并将文件Example.txt的所有内容复制到此文件。

获取目录内容

class Example {

   static void main(String[] args) {
      def rootFiles = new File('test').listRoots()
      rootFiles.each {
         file -> println file.absolutePath
      }
   }

}
//打印:
C:\
D:\
G:\

new File()入参也可以是某个指定的目录,那么会把目录下的文件和文件夹都打印出来。例如:

D:\学习\groovy\Code\groovy-project\.\Directory
D:\学习\groovy\Code\groovy-project\.\Example.groovy
D:\学习\groovy\Code\groovy-project\.\Example.txt
D:\学习\groovy\Code\groovy-project\.\Example1.txt

如果要递归显示目录及其子目录中的所有文件,则可以使用File类的eachFileRecurse函数。以下示例显示如何完成此操作。

十、字符串

字符串可以用单引号''、""、"''"括起来。此外,由三重引号括起来的Groovy字符串可以跨越多行。

如下:

class Example {

   static void main(String[] args) {
      String a = 'Hello Single'
      String b = 'Hello Double'
      String c = """Hello Triple
      Multiple lines"""

      println(a)
      println(b)
      println(c)
   }

}

//打印:
Hello Single
Hello Double
Hello Triple
      Multiple lines

字符串索引

class Example { 
   static void main(String[] args) { 
      String sample = "Hello world"; 
      println(sample[4]); // Print the 5 character in the string
		
      //Print the 1st character in the string starting from the back 
      println(sample[-1]); 
      println(sample[1..2]);//Prints a string starting from Index 1 to 2 
      println(sample[4..2]);//Prints a string starting from Index 4 back to 2 
      
   } 
}
//打印:
o 
d 
el 
oll 

十一、范围

范围是指定值序列的速记。一些范例文字的例子 -

  • 1…10 - 包含范围的示例
  • 1 … <10 - 独占范围的示例
  • ‘a’…‘x’ - 范围也可以由字符组成
  • 10…1 - 范围也可以按降序排列
  • ‘x’…‘a’ - 范围也可以由字符组成并按降序排列。
def list1 = 1..10
def list2 = 1..<10
def list3 = 'a'..'x'
def list4 = 10..1
def list5 = 'x'..'a'

println list1.size()
println list2.size()
println list3.size()
println list4.size()
println list5.size()
//打印:
10
9
24
10
24

十二、列表

groovy 列表使用索引操作符 [] 索引。列表索引从 0 开始,指第一个元素。

groovy 中的一个列表中的数据可以是任意类型。这 java 下集合列表有些不同,java 下的列表是同种类型的数据集合。

List.reverse() 可以实现列表反转。调用 List.sort() 可以实现列表排序。

def list1 = []  
def list2 = [1,2,3,4]  
list2.add(12)  
list2.add(12)  
println list1.size()
println list2.size()
//打印:
0
6

1、搜索-find

class Example {

   static void main(String[] args) {
      def list = [1, 2, 3, 1, 2, 3];

      //find:返回第一个符合条件的项
      def find = list.find({
         item ->
            {
                  item == 1
            }
      })
      println(find); // 1

      //findAll:返回所有符合条件的项
      def findA = list.findAll({
         item ->
            {
                  item == 1
            }
      })
      println(findA); //[1,1]

      //findIndexOf:返回满足条件的第一个元素的下标值。
      def index = list.findIndexOf({
         item ->
            {
                  item == 1
            }
      })
      println(index); //   0

   }

}

2、排序-sort、reverse

class Example {

   static void main(String[] args) {
      def list = [1, 2, 3, 1, 2, 3];
      
      //sort-正序排序
      def list1=list.sort();
      println(list1);
      
      //sort-倒叙排序
      def list2=list.sort({
         a, b -> a - b ? -1 : 1
      });
      println(list2);

      // reverse:将原list倒序,返回一个新的list
      def list3=list.reverse();
      println(list3);
   }

}
//打印:
[1, 1, 2, 2, 3, 3]
[3, 3, 2, 2, 1, 1]
[1, 1, 2, 2, 3, 3]

3、返回新数组-collect、tail

class Example {

   static void main(String[] args) {
      def list = [1, 2, 3, 1, 2, 3];
      
      //collect:返回一个新的list,他可以接受一个闭包参数或者无参。类似js中map。it是闭包中自带的隐式变量;
      def doCollect = list.collect({
         return it - 1;
      })
      println(doCollect)

      // tail:返回一个新的list,它包含list中的所有的元素(除了第一个元素)
      def doTail=list.tail();
      println(doTail)

      // 一个累积的过程方法(有点像js的reduce),传入inject方法中的ini作为sum的初始值,在遍历collection的过程中,将处理结果(“$sum $elem”)保存到sum中。
      def doInject=list.inject("ini") {
         sum, elem -> "$elem $sum"
      }
      println(doInject)
   }

}

// 打印:
// [0, 1, 2, 0, 1, 2]
// [2, 3, 1, 2, 3]
// 3 2 1 3 2 1 ini

4、遍历

each、eachWithIndex

class Example {

   static void main(String[] args) {
      def list = [1, 2, 3, 1, 2, 3];
      
      //each:普通的迭代遍历
      list.each({
         it -> println(it)
      })

      //eachWithIndex:他的作用和each一样,但是他要传入一个闭包,有两个参数,一个是值,一个是索引。
      list.eachWithIndex { int entry, int i ->
         {
            println( "${entry}--${i}")
         }
      }
   }

}

// 打印:
// 1
// 2
// 3
// 1
// 2
// 3
// 1--0
// 2--1
// 3--2
// 1--3
// 2--4
// 3--5

every、any、first、last、max、min、count、unique

class Example {

   static void main(String[] args) {
      def list = [1, 2, 3, 1, 2, 3];
      
      //every:接收一个闭包,返回为一个布尔值,当所有条件都满足时才返回true
      def flag1=list.every({
         it -> it>0
      })
      println(flag1);

      //any:和every用法一样,只要有一个为true,则返回true
      def flag2=list.any({
         it -> it>0
      })
      println(flag2);

      //返回第一个数据
      println(list.first());
      //返回最后一个数据
      println(list.last());
      //返回最大值
      println(list.max());
      //返回最小值
      println(list.min());
      //返回总和
      println(list.sum());
      //返回某项出现的次数
      println(list.count(3));
      //返回去重后的数组
      println(list.unique());
   }

}

// 打印:
// true
// true
// 1
// 3
// 3
// 1
// 12
// 2
// [1, 2, 3]

5、分组

class Example {

   static void main(String[] args) {      
      def items = [[name:"tony", age:4], [name:"tony", age: 5], [name:"alan", age:16]]
      def groups = items.groupBy {it.name}
      println(groups);
   }

}

// 打印:
// [tony:[[name:tony, age:4], [name:tony, age:5]], alan:[[name:alan, age:16]]]

6、包含

class Example {

   static void main(String[] args) {
      def list = [1, 2, 3, 1, 2, 3];
      def list2 = [1, 2, 3,4];
      
      println(list.containsAll(list2));
      println(list2.containsAll(list));
   }

}

// 打印:
// false
// true

十三、映射

映射(也称为关联数组,字典,表和散列)是对象引用的无序集合。Map集合中的元素由键值访问。 Map中使用的键可以是任何类。当我们插入到Map集合中时,需要两个值:键和值

以下是一些映射的例子

  • [‘TopicName’:‘Lists’,‘TopicName’:‘Maps’] - 具有TopicName作为键的键值对的集合及其相应的值。
  • [:] - 空映射。
class Example { 
   static void main(String[] args) { 
      def mp = ["TopicName" : "Maps", "TopicDescription" : "Methods in Maps"] 
      println(mp.get("TopicName")); 
      println(mp.get("Topic")); 
   } 
}

十四、日期和时间

class Example {

   static void main(String[] args) {
      Date date = new Date()

      println(date.toString())   //Mon Jun 19 13:15:20 CST 2023
      println(date.getDateString()) //2023/6/19
      println(date.dateTimeString)  //2023/6/19 13:15:20
      // 格式化时间
      println(date.format('yyyy-MM-dd HH:mm:ss'))  //2023-06-19 13:15:20

      // after 测试此日期是否在指定日期之后
      Date oldDate = new Date('05/11/2015')
      Date newDate = new Date('05/12/2022')
      Date latestDate = new Date()

      println(oldDate.after(newDate))  //false
      println(latestDate.after(newDate))  //true

      // equals 比较两个日期的相等性。当且仅当参数不为null时,结果为true,并且是表示与该对象时间相同的时间点(毫秒)的Date对象
      println(oldDate.equals(newDate)) //false
      println(latestDate.equals(newDate)) //false

      // 返回自此Date对象表示的1970年1月1日,00:00:00 GMT以来的毫秒数
      println(oldDate.getTime()) //1431273600000
   }

}
// Date.getTime() 获取时间戳
// Date.setTime(long time) 返回时间戳

十五、正则表达式

Groovy使用~”pattern” 来支持正则表达式,它将使用给定的模式字符串创建一个编译好的Java Pattern 对象。Groovy也支持 =~(创建一个Matcher)和 ==~ (返回boolean,是否给定的字符串匹配这个pattern)操作符。

定义正则可以使用 ~+字符串、/正则表达式/ 这两种方式来定义一个正则表达式,具体如下:

class Example {

   static void main(String[] args) {
      def reg1 = ~'he*llo'
      def reg2 = /he*llo/
      println "reg1 type is ${reg1.class}"
      println "reg2 type is ${reg2.class}"
      println 'hello'.matches(reg1)
      println 'hello'.matches(reg2)
   }

}
//打印
reg1 type is class java.util.regex.Pattern
reg2 type is class java.lang.String
true
true

注意:上述例子中的~= 之间有一个空格, 因为Groovy中存在=~ 操作符号, 这个操作符为查询操作符, 使用在字符串之后, 要求接一个正则表达式, 返回的是一个java.util.regex.Matcher 对象. 还有一个操作符==~ 也比较容易混淆,这个操作符为匹配操作符, 后面跟一个正则表达式, 返回的类型为Boolean 类型。

def val1 = "hello" =~ "he*llo"
println val1.class
println val1.matches()

def val1 = "hello" ==~ "he*llo"
println val1.class
println val1

//打印:
class java.util.regex.Matcher
true
class java.lang.Boolean
true

匹配字符串

class Example {

   static void main(String[] args) {
      def reg = ~/h(el)(lo)/
      def str = 'hello world hello nihao'
      def matcher = str =~ reg
      println 'first matched substring'
      println matcher[0]
      println matcher[0][0]
      println matcher[0][1]
      println matcher[0][2]
      println 'second matched substring'
      println matcher[0]
      println matcher[0][0]
      println matcher[0][1]
      println matcher[0][2]
   }

}
//打印
first matched substring
[hello, el, lo]
hello
el
lo
second matched substring
[hello, el, lo]
hello
el
lo

十六、异常处理

class Example {
   static void main(String[] args) {
      try {
         def arr = new int[3];
         arr[5] = 5;
      }catch(ArrayIndexOutOfBoundsException ex) {
         println("Catching the Array out of Bounds exception");
      }catch(Exception ex) {
         println("Catching the exception");
      }finally {
         println("The final block");
      }
        
      println("Let's move on after the exception");
   } 
}

//打印
Catching the Array out of Bounds exception
The final block
Let's move on after the exception

十七、面向对象

1、类

class Example { 
   static void main(String[] args) { 
      Student st = new Student(); 
      st.StudentID = 1;

      st.Marks1 = 10; 
      st.name="Joe"; 
        
      println(st.name); 
      println(st.DisplayMarks()); 
   } 
} 

abstract class Person { 
   public String name; 
   public Person() { } 
   abstract void DisplayMarks();
}
 
class Student extends Person { 
   int StudentID 
   int Marks1; 
    
   public Student() { 
      super(); 
   } 
    
   void DisplayMarks() { 
      println(Marks1); 
   }  
} 
//打印
Joe 
10 

2、接口

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;
      println(st.DisplayMarks());
   } 
} 

interface Marks { 
   void DisplayMarks(); 
} 

class Student implements Marks {
   int StudentID
   int Marks1;
	
   void DisplayMarks() {
      println(Marks1);
   }
}
//打印
10

十八、泛型

1、类

class Example {
   static void main(String[] args) {
      // Creating a generic List collection 
      ListType<String> lststr = new ListType<>();
      lststr.set("First String");
      println(lststr.get()); 
		
      ListType<Integer> lstint = new ListType<>();
      lstint.set(1);
      println(lstint.get());
   }
} 

public class ListType<T> {
   private T localt;
	
   public T get() {
      return this.localt;
   }
	
   public void set(T plocal) {
      this.localt = plocal;
   } 
}
//打印
First String
1

2、集合的通用

可以对集合类(如List类)进行一般化,以便只有该类型的集合在应用程序中被接受。

class Example {
   static void main(String[] args) {
      // Creating a generic List collection
      List<String> list = new ArrayList<String>();
      list.add("First String");
      list.add("Second String");
      list.add("Third String");
		
      for(String str : list) {
         println(str);
      }
   } 
}

十九、特征

使用trait关键字定义 trait。然后可以使用 implement 关键字以类似于接口的方式实现 trait。

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10; 
      println(st.DisplayMarks());
   } 
} 

trait Marks { 
   void DisplayMarks() {
      println("Display Marks");
   } 
} 

class Student implements Marks { 
   int StudentID
   int Marks1;
}

实现接口

class Example {
   static void main(String[] args) {
      Student st = new Student();
      st.StudentID = 1;
      st.Marks1 = 10;
		
      println(st.DisplayMarks());
      println(st.DisplayTotal());
   } 
} 

interface Total {
   void DisplayTotal() 
} 

trait Marks implements Total {
   void DisplayMarks() {
      println("Display Marks");
   }
	
   void DisplayTotal() {
      println("Display Total"); 
   } 
} 

class Student implements Marks { 
   int StudentID
   int Marks1;  
} 

//打印
Display Marks 
Display Total

二十、闭包

  • 闭包可以接收入参
  • 闭包可以引用外部变量
class Example {     
   static void main(String[] args) {
      def str1 = "Hello";
      def clos = {param -> println "${str1} ${param}"}
      clos.call("World");
		
      // We are now changing the value of the String str1 which is referenced in the closure
      str1 = "Welcome";
      clos.call("World");
   } 
}

//打印
Hello World 
Welcome World

it是闭包中提供的隐式变量。当闭包没有显式声明的参数时可用。当闭包与诸如removeIf的收集方法一起使用时,it将指向当前的迭代项.

List<Integer> integers = [1, 2, 3]
for(Integer it: integers) {print(it)}

推荐阅读

Groovy 教程

你可能感兴趣的:(jvm,java,windows)