Groovy的基础语法
- 格式：docx
- 大小：17.47 KB
- 文档页数：12
下载文档原格式
合集下载
groovy try语句
groovy try语句在Groovy中，try语句用于捕获可能会抛出异常的代码块，并在异常发生时执行相应的处理逻辑。
try语句通常和catch和finally语句一起使用。
try语句的基本语法如下：groovy.try {。
// 可能会抛出异常的代码块。
} catch (ExceptionType e) {。
// 捕获特定类型的异常并执行相应的处理逻辑。
} finally {。
// 无论是否发生异常，都会执行的代码块。
}。
在try语句中，首先是try块，其中包含可能会抛出异常的代码。
如果在try块中抛出了异常，程序会立即跳转到与抛出的异常类型匹配的catch块。
catch块用于捕获特定类型的异常，并执行相应的处理逻辑。
在catch块中，你可以访问异常对象（通常命名为e），以便获取异常的相关信息。
如果没有catch块匹配抛出的异常类型，异常会继续向上层调用栈传播，直到找到匹配的catch块或者到达顶层调用栈。
无论是否发生异常，finally块中的代码都会被执行。
通常在finally块中放置一些清理资源的代码，例如关闭文件或释放其他资源。
除了基本的try-catch-finally结构，Groovy还支持try-with-resources语句，用于自动管理资源的关闭。
这种语句类似于Java 7中引入的try-with-resources语句，可以在try语句中声明资源，然后在try块执行完毕后自动关闭这些资源。
总之，try语句在Groovy中扮演着捕获和处理异常的重要角色，能够帮助我们编写健壮的程序并进行合理的异常处理。
希望这个回答能够满足你的要求，如果有其他问题，请随时提出。
Groovy的基础语法
Groovy的基础语法Groovy的基础语法Groovy 的语法融合了Ruby、Python 和Smalltalk 的一些最有用的功能，同时保留了基于Java 语言的核心语法。
对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。
语句Groovy的语句和Java类似，但是有一些特殊的地方。
例如语句的分号是可选的。
如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12 另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。
动态类型像其他Script一样，Groovy 不需要显式声明类型。
在Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。
在Groovy中，类型对于值(varibles)、属性(properties)、方法(method)和闭包(closure)参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声明了类型的除外）。
例如：//Groovy 动态类型myStr = "Hello World"由于使用了动态类型，不需要继承就可以得到多态的全部功能：class Song{ Property length Property name }class Book{ def public name def public author }def doSomething(thing){ println "going to do something with a thing named = " + }这里定义了两个Groovy 类，Song 和Book。
这两个类都包含一个name 属性。
函数doSomething，它以一个thing 为参数，并试图打印这个对象的name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个name 属性，那么它就可以工作。
groovy语言基本语法
groovy语言基本语法Groovy语言是一种可编程和动态的面向对象语言，它拥有Java的风格和功能。
它是一个新的运行时环境，具有强大的扩展性和可扩展性，可用于开发快速和可扩展的应用程序。
Groovy语言基本语法包括变量、类型、异常处理、语句、注释、操作符、函数、类和对象等。
一、变量Groovy语言中没有显式声明变量类型的语法，而是使用“def”关键字来定义变量。
例如：Def num = 1在上面的代码中，我们定义了一个叫做num的变量，它的类型将根据变量值的类型而变化。
二、类型Groovy语言支持使用Java的基本类型，如int，long，float和double，以及某些特殊类型，例如Range，Closure，GString，Map等。
三、异常处理Groovy在处理异常时export使用try catch语句，而不是Java中的throws关键字。
它允许程序员在需要时捕获和处理异常。
例如：try{// do something}catch (Exception e){// exception handling}四、语句Groovy和java一样具有if，for，while，switch和do-while等语句，但是它支持一些其他的语句，例如delegate，synchronized和with等。
五、注释Groovy支持单行和多行注释，使用“//”和“/* */”表示各自的注释。
六、操作符Groovy有多种操作符，如算术操作符、比较操作符、赋值操作符、逻辑操作符、三元操作符等。
七、函数Groovy支持定义和调用自定义函数。
它也允许使用现有函数，如Math.abs（）或String.trim（）等。
八、类和对象Groovy语言中的类和对象是用"class"关键字来定义的，它有着与Java相同的语法，不同之处在于它支持更灵活的定义方式，如可以继承抽象类，具有更灵活的可访问性等特点。
groovy template 语法
groovy template 语法Groovy模板（Groovy Template）是使用Groovy语言编写的模板引擎，它可以用于生成动态文本输出。
下面是Groovy模板的语法简介：1.定义模板：groovy复制代码def template = '''<html><head><title>${title}</title></head><body><h1>${heading}</h1><p>${content}</p></body></html>'''在上面的示例中，我们定义了一个名为template的模板字符串，其中包含了Groovy的模板语法。
在模板中，我们使用了${...}语法来嵌入变量，这些变量将在模板被填充时替换为实际的值。
2.填充模板：groovy复制代码def title = 'My Page'def heading = 'Welcome to My Page'def content = 'This is some content.'def filledTemplate = e { it ->it.title = titleit.heading = headingit.content = content}在上面的示例中，我们定义了三个变量title、heading和content，分别表示页面的标题、标题和内容。
然后，我们使用use方法来填充模板。
在use方法的闭包中，我们通过访问模板中的变量并为其赋值来填充模板。
最后，我们将填充后的模板赋值给filledTemplate变量。
3.输出模板：groovy复制代码println filledTemplate.toString()在上面的示例中，我们使用toString方法将填充后的模板转换为字符串，并使用println方法将其输出到控制台。
groovy if判断
groovy if判断Groovy if判断Groovy是一种基于Java的动态脚本语言，它非常适合用于编写脚本和快速开发应用程序。
在Groovy中，if判断是一种常用的控制语句，用于根据条件执行不同的代码块。
本文将介绍Groovy中的if判断语句的使用方法和注意事项。
一、基本语法在Groovy中，if判断的基本语法如下：```if (条件) {// 如果条件成立，执行这里的代码块} else {// 如果条件不成立，执行这里的代码块}```其中，条件可以是任何可以返回布尔值的表达式。
如果条件成立，即为true，就会执行if代码块中的内容；如果条件不成立，即为false，就会执行else代码块中的内容。
二、示例代码下面是一个简单的示例代码，演示了if判断的使用方法：```def num = 10if (num > 0) {println("num大于0")} else {println("num小于等于0")}```输出结果为："num大于0"，因为变量num的值为10，大于0。
三、多重判断在实际开发中，我们经常需要根据不同的条件执行不同的代码块。
Groovy的if判断语句可以通过多重判断来实现这一需求。
下面是一个示例代码，演示了多重判断的用法：```def score = 80if (score >= 90) {println("优秀")} else if (score >= 80) {println("良好")} else if (score >= 70) {println("中等")} else if (score >= 60) {println("及格")} else {println("不及格")}```根据变量score的值不同，会输出不同的结果。
groovy基本语法--JSON
groovy基本语法--JSON1、groovy提供了对JSON解析的⽅法①JsonSlurper JsonSlurper是⼀个将JSON⽂本或阅读器内容解析为Groovy数据的类结构，例如map，列表和原始类型，如整数，双精度，布尔和字符串。
②JsonOutput 此⽅法负责将Groovy对象序列化为JSON字符串2、解析JSON字符串def jsonSlurper = new JsonSlurper()def object = jsonSlurper.parseText('{ "name": "John", "ID" : "1"}')println()println(object.ID)结果输出如下：John13、解析JSON数组def jsonSlurper = new JsonSlurper()Object lst = jsonSlurper.parseText('{ "List": [2, 3, 4, 5] }')lst.each { println it }结果输出如下：List=[2, 3, 4, 5]4、解析基本数据类型列表def jsonSlurper = new JsonSlurper()def obj = jsonSlurper.parseText ''' {"Integer": 12, "fraction": 12.55, "double": 12e13}'''println(obj.Integer)println(obj.fraction)println(obj.double)结果输出如下：1212.551.2E+145、转换JSON字符串//直接创建JSONdef output = JsonOutput.toJson([name: 'John', ID: 1])println(output)结果输出为：{"name":"John","ID":1}//根据对象⽣成JSONclass Student {String nameint ID}def outputs = JsonOutput.toJson([ new Student(name: 'John',ID:1),new Student(name: 'Mark',ID:2)])println(outputs)结果输出为：[{"name":"John","ID":1},{"name":"Mark","ID":2}。
groovy数组基本语法
groovy数组基本语法Groovy是一种基于Java的动态语言，它继承了Java的语法和库，并且提供了更加便捷的编程体验。
在Groovy中，数组是一种非常重要的数据结构，它可以存储多个相同类型的元素，并且支持各种常见的操作。
本文将介绍Groovy数组的基本语法。
一、定义数组1.使用[]运算符在Groovy中，可以使用[]运算符来定义一个数组。
例如：def arr = [1, 2, 3]这样就定义了一个包含三个元素（分别为1、2、3）的整型数组arr。
2.使用Array类Groovy也提供了Array类来创建数组对象。
例如：def arr = new Array(3)这样就创建了一个包含三个元素（默认值为null）的Object类型数组arr。
3.指定元素类型如果需要指定数组元素类型，可以使用[]运算符或者Array类的构造函数。
例如：def intArr = [1, 2, 3] as int[]def strArr = new String[3]这样就分别创建了一个整型数组intArr和一个字符串类型数组strArr。
二、访问元素在Groovy中，可以使用下标来访问数组中的元素。
下标从0开始计数。
例如：def arr = [1, 2, 3]assert arr[0] == 1assert arr[1] == 2assert arr[2] == 3三、修改元素可以使用下标来修改数组中的元素。
例如：def arr = [1, 2, 3]arr[1] = 4assert arr == [1, 4, 3]四、遍历数组在Groovy中，可以使用for循环或者each方法来遍历数组。
例如：def arr = [1, 2, 3]for (int i = 0; i < arr.size(); i++) {println(arr[i])}arr.each { element ->println(element)}五、数组操作Groovy提供了丰富的数组操作方法，包括排序、查找、过滤等。
Groovy
Groovy特性
语法上支持动态类型，闭包等新一代语言特性 无缝集成所有已经存在的Java类库 即支持面向对象编程也支持面向过程编码
Groovy优势
一种更加敏捷的编程语言 入门非常的容易，单功能非常的强大 即可以作为编程语言也可以作为脚本语言 熟练掌握Java的同学会非常容易掌握Groovy
Groovy语法讲解
DSL介绍
全称domain specific language 有哪些常见的DSL语言及特点 DSL与通用编程语言的区别 核心思想：求专不求全，解决特定问题
Groovy介绍
是一种基于JVM的敏捷开发语言 结合了Python、Ruby和Smalltalk的许多强大的特性 Groovy可以与Java完美结合，而且可以使用java所有的库
Groovy中列表 Groovy中的映射 Groovy中的范围
第四部分 面向对象
Groovy中类、接口、方法等的定义和使用 Groovy中的元编程
Groovy高级语法
Groovy json操作详解 Groovy xml文件操作详解 Groovy 文件操作详解 Groovy与java对比及总结
groovy基础语法 groovy闭包讲解 groovy数据结构 groovy面向对象
第一部分oovy中的逻辑控制讲解
第二部分 闭包
groovy中闭包基础讲解 groovy中闭包使用讲解 groovy中闭包进阶讲解
第三部分 数据结构
Groovy学习总结
Groovy变量，字符串，循环等基本语法 Groovy中的数据结构：列表、映射、范围用法 Groovy中方法、类等面向对象相关知识 Groovy中对普通文件、xml、json处理
文件操作
Groovy中如何解析一个xml格式数据 Groovy中如何创建一个xml格式数据 所有java对文件的处理类，groovy都可以使用 Groovy扩展了许多更加快捷和强大的方法
Groovy的基础语法
Groovy的基础语法Groovy的基础语法Groovy 的语法融合了Ruby、Python 和Smalltalk 的一些最有用的功能，同时保留了基于Java 语言的核心语法。
对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。
语句Groovy的语句和Java类似，但是有一些特殊的地方。
例如语句的分号是可选的。
如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12 另外return关键字在方法的最后是可选的；同样，返回类型也是可选（缺省是Object）。
动态类型像其他Script一样，Groovy 不需要显式声明类型。
在Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。
在Groovy中，类型对于值(varibles)、属性(properties)、方法(method)和闭包(closure)参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声明了类型的除外）。
例如：//Groovy 动态类型myStr = "Hello World"由于使用了动态类型，不需要继承就可以得到多态的全部功能：class Song{ Property length Property name }class Book{ def public name def public author }def doSomething(thing){ println "going to do something with a thing named = " + }这里定义了两个Groovy 类，Song 和Book。
这两个类都包含一个name 属性。
函数doSomething，它以一个thing 为参数，并试图打印这个对象的name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个name 属性，那么它就可以工作。
Groovy PPT
ቤተ መጻሕፍቲ ባይዱ
自定义Range
class Section implements Comparable{ def SECTION_TYPE = ['Yike','Erke','Sanke','Sike','Wuke']// private index = 0 public Section(type){ this.index = SECTION_TYPE.indexOf(type) } Section next(){ new Section(SECTION_TYPE[(index+1)%SECTION_TYPE.size()]) } Section previous(){ new Section(index-1) } int compareTo(Object other){ index<=>other.index } public String toString(){ SECTION_TYPE[index] } } 类似JAVA中的enum类
可自动转换的类型
动态类型通常可以随意转换，静态类型只在可转换时才能转 换，否则抛出异常，如：
def s =[“name”:1]; s =“test”; println s;（可执行） println s;（类型转换异常）
Map s =[“name”:1]; s =“test”; String s =“test” s = [“name”:1] as Map println s.class
（可执行，class为string）
类型转换：赋的值都将转换为定义类型
注：static main(args)中的参数默认定义为静态string
自定义Range
class Section implements Comparable{ def SECTION_TYPE = ['Yike','Erke','Sanke','Sike','Wuke']// private index = 0 public Section(type){ this.index = SECTION_TYPE.indexOf(type) } Section next(){ new Section(SECTION_TYPE[(index+1)%SECTION_TYPE.size()]) } Section previous(){ new Section(index-1) } int compareTo(Object other){ index<=>other.index } public String toString(){ SECTION_TYPE[index] } } 类似JAVA中的enum类
可自动转换的类型
动态类型通常可以随意转换，静态类型只在可转换时才能转 换，否则抛出异常，如：
def s =[“name”:1]; s =“test”; println s;（可执行） println s;（类型转换异常）
Map s =[“name”:1]; s =“test”; String s =“test” s = [“name”:1] as Map println s.class
（可执行，class为string）
类型转换：赋的值都将转换为定义类型
注：static main(args)中的参数默认定义为静态string
groovy用法
groovy用法Groovy是一种基于Java平台的动态编程语言，它是一种面向对象的语言，同时也支持函数式编程。
Groovy可以与Java代码无缝集成，同时具有更加简洁、灵活和易于使用的语法。
本文将介绍Groovy的用法，包括安装、基本语法、面向对象编程、函数式编程以及与Java 集成等方面。
一、安装在使用Groovy之前，需要先安装它。
可以从官网下载最新版本的Groovy，并按照指示进行安装。
在安装完成后，需要将Groovy的bin目录添加到系统路径中，以便在命令行中直接使用groovy命令。
二、基本语法1. 变量与数据类型在Groovy中，变量的声明和赋值可以同时进行。
例如：```def name = "Tom"```这里使用了关键字def来声明一个变量name，并将其赋值为"Tom"。
Groovy支持多种数据类型，包括字符串、整数、浮点数、布尔值等。
例如：```def str = "Hello, World!"def num1 = 123def num2 = 3.14def bool = true```2. 控制流程语句Groovy支持常见的控制流程语句，包括if-else语句、for循环和while循环等。
例如：```if (score >= 60) {println("及格了")} else {println("不及格")}for (i in 1..10) {println(i)}def i = 1while (i <= 10) {println(i)i++}```3. 函数在Groovy中，函数的定义和调用非常简单。
例如：```def add(int a, int b) {return a + b}println(add(1, 2))```这里定义了一个名为add的函数，接受两个整数参数a和b，并返回它们的和。
groovy教程
groovy教程Groovy是一种在Java虚拟机上运行的动态编程语言，旨在提供更简洁、易于阅读和易于编写的代码。
它具有很多与Java相似的特性，并且可以直接与Java代码进行互操作。
以下是关于Groovy的一些重要概念和用法。
1. 基本语法和变量类型：- Groovy使用与Java相同的语法结构，如变量声明、条件语句、循环等。
- 定义变量时不需要指定数据类型，Groovy会根据变量的值自动推导类型。
- Groovy支持动态类型，变量的类型可以在运行时改变。
2. 字符串操作：- Groovy提供了许多方便的字符串操作方法，如拼接字符串、格式化字符串等。
- 在Groovy中，字符串可以用单引号或双引号括起来，同时支持三重引号用于处理多行字符串。
3. 列表和映射：- 列表是Groovy中常用的数据结构，可以存储多个值，并支持各种操作，如添加、删除、遍历等。
- 映射是一种键值对的集合，类似于Java中的Map，可以用于存储和访问键值对数据。
4. 方法和闭包：- Groovy中的方法定义与Java类似，可以包含参数和返回值。
方法的调用用点运算符表示。
- 闭包是一种特殊的代码块，可以作为参数传递给其他方法，也可以存储到变量中。
闭包可以访问其外部作用域的变量。
5. 文件操作：- Groovy提供了简化文件操作的方法，如读取文件内容、写入文件等。
- 可以使用Groovy的文件对象来进行文件操作，其方法包括读取行、追加行等。
6. 单元测试：- Groovy具有内置的单元测试框架，可以方便地编写和运行测试用例。
使用注解`@Test`标记测试方法。
7. 与Java的互操作：- Groovy可以无缝地与Java代码进行互操作，可以直接调用Java类和方法，也可以将Groovy代码作为库使用在Java项目中。
以上是关于Groovy的一些基本概念和常用用法。
通过学习和实践，您将能够更好地理解和应用Groovy编程语言。
groovy常用语法及实战
groovy常⽤语法及实战groovy语⾔简介⼀种基于JVM的敏捷开发语⾔，作为编程语⾔可编译成java字节码，也可以作为脚本语⾔解释执⾏。
结合了Python、Ruby和Smalltalk的许多强⼤的特性⽀持⾯向对象编程也⽀持⾯向过程编程⽀持动态类型，闭包等语⾔特性⽆缝集成所有已经存在的java类库groovy环境搭建参考官⽹groovy的hello world在groovy语⾔中，如下两种写法效果完全相同版本1：class HelloGroovy {public static void main(String[] args) {System.out.println("hello groovy!");}}版本2：print"hello groovy"版本2看起来是脚本，其实是编译器帮我们变成了class，版本2脚本对应的class反编译为如下代码：import ng.Binding;import ng.Script;import org.codehaus.groovy.runtime.InvokerHelper;public class HelloGroovy extends Script {public HelloGroovy() {}public HelloGroovy(Binding context) {super(context);}public static void main(String... args) {InvokerHelper.class.invoke<invokedynamic>(InvokerHelper.class, HelloGroovy.class, args);}public Object run() {return this.invoke<invokedynamic>(this, "hello groovy");}}我们直观感受⼀个是编译语⾔，⼀个是脚本语⾔，但其实最后都是编译执⾏的。
groovy 字符串语法
Groovy是一种基于Java平台的动态编程语言，它具有简洁、易读和富有表现力的语法。
在Groovy中，字符串是一种非常重要的数据类型，具有丰富的语法和功能。
下面是一些Groovy 字符串的常见语法和用法：1. 创建字符串：可以使用单引号或双引号创建字符串。
例如：```groovyString greeting = "Hello"String name = "Alice"```2. 字符串拼接：可以使用加号（+）将字符串连接起来。
例如：```groovyString message = "Hello, " + name + "!"```3. 转义字符：在Groovy中，可以使用反斜杠（\）来转义特殊字符，例如换行符（\n）、制表符（\t）等。
例如：```groovyString multiLineString = "Hello\nWorld"```4. 格式化字符串：可以使用printf格式化字符串，根据指定的格式输出变量的值。
例如：```groovyint age = 25String name = "Alice"String formatted = "My name is $name, and I am $age years old."String result = formatted.execute(age, name)```5. 字符串分割：可以使用split方法将字符串按照指定的分隔符分割成多个子字符串。
例如：```groovyString sentence = "This is a, sample sentence."String[] words = sentence.split(", ")```6. 字符串替换：可以使用replace方法将字符串中的指定子串替换为新的子串。
Groovy编程语言基础指南
Groovy编程语言基础指南第一章：Groovy简介Groovy是一种基于Java平台的动态编程语言，它允许开发人员使用简洁的语法和动态性能来编写高效的应用程序。
本章将介绍Groovy的背景和特点，以及它与Java之间的关系。
1.1 Groovy的起源Groovy最早由James Strachan于2003年创建，他希望设计一种可以充分利用Java平台的语言，同时通过简洁的语法和动态性能提高开发效率。
Groovy从Java语法中借鉴了很多特性，并引入了很多新的概念和功能。
1.2 Groovy与JavaGroovy可以与Java代码无缝地集成，因为它们之间的语法非常相似。
Groovy源代码可以直接引用Java类和方法，反之亦然。
这使得Groovy成为Java开发人员的理想选择，他们可以在使用Java的同时享受到Groovy的优势。
第二章：Groovy的基本语法本章将介绍Groovy的基本语法，包括变量、数据类型、运算符、流程控制和异常处理等内容。
2.1 变量和数据类型Groovy支持动态类型和静态类型两种变量声明方式。
变量的命名规则与Java相同，并且支持Java中的基本数据类型以及更多高级数据类型。
2.2 运算符Groovy支持Java的所有运算符，并且还引入了一些新的运算符。
例如，Groovy中的安全导航运算符（?.）可以避免空指针异常。
2.3 流程控制Groovy支持与Java相同的流程控制结构，包括条件语句、循环语句和跳转语句。
与Java相比，Groovy的语法更加简洁，使得代码易于阅读和编写。
2.4 异常处理Groovy使用try-catch-finally块来处理异常，与Java相同。
同时，Groovy还提供了带有简化语法的断言和前置条件检查功能。
第三章：Groovy的面向对象编程本章将介绍Groovy的面向对象编程特性，包括类和对象的定义、继承和多态等。
3.1 类和对象与Java一样，Groovy中的类也由属性和方法组成。
groovy script 语法
一、介绍Groovy Script是一种基于Java的动态脚本语言，它结合了Python、Ruby和Smalltalk的特性，旨在提供简单、优雅的语法和强大的功能。
它可以无缝地与Java代码集成，使得开发者可以利用现有的Java库和框架，并且相对于Java来说，Groovy更加灵活和简洁。
二、基本语法1. 变量声明和赋值在Groovy中，变量的声明和赋值可以同时进行，不需要显式地指定变量的类型。
例如：```groovydef number = 10```2. 控制流Groovy支持与Java类似的if-else、switch-case等控制流语句，但是语法更加简洁。
例如：```groovydef age = 18if (age < 18) {println "未成年"} else {println "成年人"}```3. 循环Groovy支持与Java类似的for、while循环，但是语法更加简洁。
例如：```groovydef numbers = [1, 2, 3, 4, 5]for (number in numbers) {println number}```4. 方法定义在Groovy中，可以使用关键字def来定义一个方法，不需要指定返回类型。
例如：```groovydef sayHello(String name) {println "Hello, $name!"}```5. 字符串处理Groovy支持使用单引号和双引号定义字符串，并且支持字符串插值。
例如：```groovydef name = "Alice"def age = 20def message = "My name is $name, and I am $age years old." ```6. 闭包Groovy支持闭包，可以使用类似lambda表达式的方式进行定义和使用。
Groovy基础——MetaClass详解
博客分类：这篇文章将对Groovy的其中一个核心内容MetaClass(MOP)讲解。
由于该部分内容较多。
所以还是利用一个个例子逐步的阐述。
一、拦截方法调用和参数获取示例1：Java代码1.class MyClass{2. def hello(){3.'invoked hello directly'4. }5. def invokeMethod(String name, Object args){6.return"unknown method $name(${args.join(', ')})"7. }8.}9.def mine= new MyClass()10.assert mine.hello() == 'invoked hello directly'11.assert mine.foo("Mark", 19) == 'unknown method foo(Mark, 19)'首先我们在groovy脚本中定义了一个Myclass对象，在groovy中任何的对象都是实现GroovyObject并且继承GroovyObjectSupport的，在GroovyObject的接口中，我们可以看到几个方法首先是getMetaClass方法和setMetaClass方法，metaClass用来支持动态方法和动态参数的调用。
另一组方法是getProperty和setProperty方法，这组方法是用来支持动态参数的设定与赋值的。
最后还有一个invokeMethod方法，该方法则是用于调用动态方法的。
在了解了上述概念后，我们可以理解为MyClass的invokeMethod方法覆盖了GroovyObjectSupport中对应的方法，所以调用未预先定义的foo方法就会进入invokeMethod的实现。
而hello方法预先定义则照旧。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Groovy 的基础语法Groovy 的基础语法Groovy 的语法融合了Ruby 、Python 和Smalltalk 的一些最有用的功能，同时保留了基于Java 语言的核心语法。
对于Java 开发人员，Groovy 提供了更简单的替代语言，且几乎不需要学习时间。
语句Groovy 的语句和Java 类似，但是有一些特殊的地方。
例如语句的分号是可选的。
如果每行一个语句，就可以省略分号；如果一行上有多个语句，则需要用分号来分隔。
x = [1, 2, 3] println x y = 5; x = y + 7 println x assert x == 12 另外return 关键字在方法的最后是可选的；同样，返回类型也是可选(缺省是Object )。
动态类型像其他Script 一样，Groovy 不需要显式声明类型。
在Groovy 中，一个对象的类型是在运行时动态发现的，这极大地减少了要编写的代码数量。
在Groovy 中，类型对于值(varibles) 、属性(properties) 、方法(method) 和闭包(closure) 参数、返回值都是可有可无的，只有在给定值的时候，才会决定它的类型，(当然声明了类型的除外) 。
例如：//Groovy 动态类型myStr = "Hello World"由于使用了动态类型，不需要继承就可以得到多态的全部功厶匕能：class Song{ Property length Property name } class Book{ def public name def public author } def doSomething(thing){ println "going to do something with a thing named = " + } 这里定义了两个Groovy 类，Song 和Book 。
这两个类都包含一个name 属性。
函数doSomething ，它以一个thing 为参数，并试图打印这个对象的name 属性，但doSomething 函数没有定义其输入参数的类型，所以只要对象包含一个name 属性，那么它就可以工作。
可见，Song 和Book 的实例都可以作为doSomething 的输入参数。
mySong = new Song(length:90, name:"Burning Down the House") myBook = new Book(name:"One Duck Stuck", author:"Phyllis Root") doSomething(mySong) //prints Burning Down the House doSomething(myBook) //prints One Duck Stuck defdoSth=this.&doSomething doSth(mySong) doSth(myBook) 在例子的最后，我们还创建了doSomething 的一个函数指针doSth ，最后的执行结果与调用doSoemthing 是一样的。
值得注意的是：与Groovy Beta 不同，在使用新的JSRGroovy 类时，类里面的所有的变量都必须加上def 关键字或者private 、protected 或public 这样的修饰符。
当然，也可以用@Property 关键字声明成员变量。
在Script 中则不必。
字符串Groovy 中的字符串允许使用双引号和单引号。
当使用双引号时，可以在字符串内嵌入一些运算式，Groovy 允许您使用与bash 类似的${expression} 语法进行替换。
可以在字符串中包含任意的Groovy 表达式。
name="James" println "My name is ${name},'00${6+1}'"//prints My name is James,'007'Groovy 还支持"uXXXX" 引用（其中X 是16 进制数），用来表示特殊字符，例如"u0040" 与"@" 字符相同。
大块文本如果有一大块文本（例如HTML 和XML ）不想编码，你可以使用Here-docs. here-docs 是创建格式化字符串的一种便利机制。
它需要类似Python 的三重引号（"""）开头，并以三重引号结尾。
hello there ${name} how are you today? ” "" assert text != nullprintln(text)name = "James" text = ""在Groovy-JSR 中，不再支持下面这种多行字符串，个人觉得似乎与Here-docs 功能重叠：foo = “ hello there how are things?println(foo)对字符串的操作contains 字符串中是否包含子字符串，'groovy'.contains('oo') 将返回true;count 返回字符串中子字符串出现的次数，'groooovy'.count('oo') 将返回 3.tokenize 根据分隔符将字符串分解成子串，'appabananaAgrap'.tokenize('A') 返回['apple','banana','grape'] 。
减操作'groovy'-'oo' ，结果是'grvy' 。
乘操作'oo'*3 ，结果是'oooooo' 。
Groovy 主要结构接下来将展示Groovy 的一些结构，包逻辑分支，类、闭包逻辑分支if-else 语句Groovy 提供Java 相同的if-else 语句。
x = false y = false if ( !x ) { x = true }assert x == true if ( x ) { x = false } else{ y = true } assert x == y Groovy 也支持三元操作符。
y = 5 x = (y > 1) ? "worked" : "failed" assert x == "worked" switch 语句Groovy 的switch 语句兼容Java 代码，但是更灵活，Groovy 的switch 语句能够处理各种类型的switch 值，可以做各种类型的匹配：case 值为类名，匹配switch 值为类实例case 值为正则表达式，匹配switch 值的字符串匹配该正则表达式case 值为集合，匹配switch 值包含在集合中，包括ranges 除了上面的，case 值与switch 值相等才匹配。
x = 1.23 result = "" switch ( x ) { case "foo": result = "found foo" // lets fall through case "bar": result += "bar" case [4, 5,6, ‘ inList ‘ ]: result = "list" break case 12..30: result = "range" breakcase Integer: result = "integer" break case Number:result = "number" break default: result ="default" } assert result == "number" Switch 语句的工作原理：switch 语句在做case 值匹配时，会调用isCase(switchValue) 方法，Groovy提供了各种类型，如类，正则表达式、集合等等的重载。
可以创建自定义的匹配类，增加isCase(switchValue) 方法来提供自定义的匹配类型。
循环while 和do 循环Groovy 支持Java 相同的while 循环，但目前暂不支持do循环x = 0 y = 5 while ( y-- > 0 ){ x++ } assert x == 5for 循环Groovy 的for 循环更简单，而且能够和各种类型的数组、集合、Map、范围等一起工作，我们稍候会详细介绍这些内容。
// iterate over a range x = 0 for ( i in 0..9 ) { x += i }assert x == 45// iterate over a listx = 0 for ( i in [0, 1, 2, 3, 4] ) { x += i } assert x == 10// iterate over an array array = (0..4).toArray() x = 0 for ( i in array ) { x += i }assert x == 10// iterate over a mapmap = [ ‘abc‘:1, ‘def ‘:2, ‘xyz‘:3] x =( e in map ) { x += e.value }assert x == 6// iterate over values in a map x = 0 for ( v in map.values() ) {x += v }assert x == 6// iterate over the characters in a string text = "abc" list = [] for (c in text){ list.add? } assert list == ["a", "b", "c"]运行Groovy 脚本你可以象使用Perl 一样编写Groovy 脚本，不需要class ，不需要Main 入口点，也不需要声明变量；此外，你还可以用def 语句来定义自己的函数，并在脚本中使用它。