Groovy_快速入门
groovy 字典定义(一)
groovy 字典定义(一)Groovy 字典定义Groovy 字典是一种在 Groovy 编程语言中常用的数据结构,它允许以键值对的形式存储和访问数据。
Groovy 字典与其他编程语言中的字典、哈希表或关联数组类似。
定义•Groovy 字典是一种动态数据结构,它可以根据需要动态添加、删除和更新键值对。
•字典中的键必须是唯一的,每个键对应一个值。
•可以使用中括号来访问字典中的值,例如myDict['key']。
•字典可以包含任意类型的值,包括字符串、整数、浮点数、列表、字典等。
例子以下是一个示例代码,展示了如何创建和使用 Groovy 字典:def myDict = ['name': 'John', 'age': 30, 'hobbies':['reading', 'painting']]println myDict['name'] // 输出:Johnprintln // 输出:30println // 输出:[reading, painting]myDict['name'] = 'Jane' // 更新键为 name 的值println myDict['name'] // 输出:Jane('age') // 移除键为 age 的键值对println myDict // 输出:[name:Jane, hobbies:[r eading, painting]]() // 清空字典println myDict // 输出:[:]书籍推荐《Groovy in Action》[book](•作者:Dierk König, Paul King, Gu illaume Laforge, Hamlet D’Arcy, Cédric Champeau, Erik Pragt, Jon Skeet•出版时间:2015年•简介:本书是 Groovy 领域的经典参考书籍之一。
GROOVY_快速入门
Groovy快速入门1、集合(1)List(java.util.List)4、collect遍历集合,逐个传递给闭包,处理后的结果返回给对应的项//Bindingbinding.setVariable("foo", GroovyShellObjectassertassertClassLoader GroovyClassLoader Class//GroovyObjectObject[]groovyObject.invokeMethod("run",args);如果你想使用一个用Groovy脚本实现的接口,你可以这么使用它:GroovyClassLoader gcl=new GroovyClassLoader();Class clazz=gcl.parseClass(myStringwithGroovyClassSource"SomeName.groovy");Object aScript=clazz.newInstance();MyInterface myObject=(MyInterface)aScript;myObject.interfaceMethod();如果某个Groovy类实现口MyInterface接口,那么上面的代码就会很好的工作.myObject的使用方法与其他实现了MyInterface接口的Java对象一样.3.Groovy脚本引擎对于那些想将Groovy脚本嵌入到服务器并且在每次修改后重新装入的人来说,Groovy脚本引擎提供了一个彻底的解决方案.你可以设定系列CLASSPATH作为根来初始化Groovy脚本引擎,这些GLASSPATH可以是URL也可以是目录名.接着你就可以这些根路径下的任何Groovy脚本了.GSE 会跟踪脚本间的依赖关系,因此如果任何有依赖关系的脚本被修改,整颗树将会重新编译和载入.另外,每次执行脚本时,你都可以传入一个包含脚本可接受属性的Binding.脚本执行完以后,传入脚本中的那些属性在Binding中依然有效.下面是一个例子:/my/groovy/script/path/hello.groovy:output="Hello,${input}!"import ng.Binding;import groovy.util.GroovyScriptEngine;String[]roots=new String[]{"/my/groovy/script/path"}; GroovyScriptEngine gse=new GroovyScriptEngine(roots);Binding binding=new Binding();binding.setVariable("input","world");gse.run("test.groovy",binding);System.out.println(binding.getVariable("output"));将打印"Hello,world!".4.运行时依赖和JDK1.4一样,Groovy Jar也依赖与ASM库上的运行时,ASM库包括4个Jar(asm-2.1.jar,asm-util-2.1.jar,asm-attrs-2.1.jar and asm-analysis-2.1).也就是说,只要将上面的5个Jar添加到路径中,你就能将轻松地Groovy嵌入到你的应用里.另一种方案可以不用那么多的Jar.你可以用GROOVY_HOME/embeddable目录下的groovy-all-1.0-beta-x.jar.这个Jar包将Groovy和ASM组合打包成一个方便的Jar包.注意:groovy-all-1.0-beta-x.jar中的ASM类使用了不同的命名空间,因此要避免与使用ASM的库发生冲突.Groovy全攻略--运行篇Groovy脚本是一个包含许多语句和类声明的文本文件.Groovy的用法和其他脚本语言类似.下面是几种运行Groovy脚本的方法:1.使用交互控制台Groovy有一个Swing交互控制台,允许你像使用SQL工具一样输入和执行Groovy语句.控制台支持历史记录,因此你可以向前或向后遍历命令.如果你已经安装了Groovy二进制分发包,你可以使用下面的命令启动Groovy Swing控制台.如果像启动命令行控制台,可以输入下面的命令:GroovyConsole如果想启动命令行控制台,可以输入下面的命令Groovysh从源代码分发包中启动Swing Groovy控制台maven console2.通过IDE运行Groovy脚本有一个叫做GroovyShell的类含有main(String[])方法可以运行任何Groovy脚本.你可以用下面的语句执行任何Groovy脚本:java ng.GroovyShell foo/MyScript.groovy[arguments你可以在你的IDE中使用上面的Groovy main()执行或调试任何Groovy脚本.3.用命令行执行Groovy脚本在GROOVY_HOME\bin里有个叫'groovy'或'groovy.bat'的脚本文件(或者二者都有,根据你的平台不同而不同).这些脚本文件是Groovy运行时的一部分.一旦安装了Groovy运行时,你就可以这样运行Groovy脚本:groovy foo/MyScript.groovy[arguments]如果你使用从CVS构建的Groovy,那么除了Groovy脚本以外,命令行上可能还运行着其他的类.1.拥有main()方法的类;2.和JUnit的测试一起运行的继承自GroovyTestCase的类,3.实现Runnable接口的类.run()方法被调用.获得最新最强的Groovy,输入下面的命令做一个CVS检出maven groovy:make-install在groovy/target/install里会有一份完整的二进制分发包.你可以将groovy/target/install/bin添加到你的路径,这样你就可以轻松地用命令行执行你的Groovy脚本了.4.用Groovy创建Unix脚本你可以用Groovy编写Unix脚本并且像Unix脚本一样直接从命令行运行它.倘若你安装的是二进制分发包并且设置好了路径,那么下面的代码将会很好的工作:将其保存为helloWorld.groovy.#!/usr/bin/env groovyprintln("Hello world")for(a in this.args){println("Argument:"+a)}接着从命令行运行这个脚本,chmod+x helloWorld./helloWorld。
groovy方法
Groovy方法1. 什么是Groovy方法?Groovy是一种基于Java语法的动态脚本语言,它结合了Python、Ruby和Smalltalk的特性,能够在Java虚拟机上运行。
Groovy方法是在Groovy语言中定义的一种可重用的代码块,用于实现特定的功能。
在Groovy中,方法是一段被命名的代码块,可以接受零个或多个参数,并且可以返回一个值。
定义方法的语法为:returnType methodName(ParameterType parameter1, ParameterType parameter2, ...) {// 方法体// 可以包含变量、流程控制语句、循环语句等return value // 如果有返回值,则使用return语句返回}Groovy方法具有以下特点: - 可以通过方法名和参数来调用方法 - 支持方法重载,即可以定义具有相同名称但参数类型或数量不同的多个方法 - 支持在方法内使用闭包和脚本块 - 可以将方法视为对象,并在其他方法中作为参数进行传递 - 可以使用注解为方法添加额外的元数据信息2. Groovy方法的定义和调用2.1 定义Groovy方法在Groovy中,可以使用关键字def来定义一个方法,该关键字表示方法的返回类型是动态的,可以根据运行时的情况进行推断。
以下是一个简单的Groovy方法的定义示例:def greet(name) {println "Hello, $name!"}上述示例定义了一个名为greet的方法,接受一个参数name,然后在控制台输出问候信息。
方法体由{}包围,方法体内部可以包含任意合法的Groovy代码。
2.2 调用Groovy方法要调用Groovy方法,可以通过方法名后加上参数列表的方式,例如:greet("Alice")上述代码会调用greet方法,并将参数"Alice"传递给方法。
Groovy轻松入门——Grails实战之GORM
Groovy轻松入门——Grails实战之GORMGORM就是以前我刚学Groovy没多久时想实现的功能它使开发人员不需要关心数据库方面也不需要任何配置只需专心用OO思想设计自己的系统还有一个好处就是开发时不用备份数据库因为GORM 会自动帮你建表以及约束(但数据库需要你自己建) 让我们来看一下用Grails开发是多么简单高效吧!在Grails +中配置稍有不同详见朝花夕拾——Groovy & Grails 在写域类时无须添加与业务无关的属性比如在用Hibernate时我们需要(不强制)在类中定义id 但用GORM时 id无须自己声明 GORM 会帮我们自动添加id和version GORM通过反射机制获得域类属性信息决定数据库字段类型所以在定义域类时不要使用def关键字来定义属性务必明确定义属性类型比如在下面的域类Article中用String来定义content(而不是def content) 在默认情况下 String映射到数据库中的字段类型是VARCHAR(Date映射到数据库中的字段类型是DATETIME) 如果通过类变量contraints定义了String的长度范围且长度过长映射到数据库中的字段类型会变为TEXT 十分智能class Article { Date dateAdded // Date 映射到数据库中的字段类型是DATETIME String content static constraints = { content(blank: false size: ) // 如果没有定义content的大小范围它在数据库中类型为VARCHAR最大长度是// 显然不满足我们的需求这样定义后数据库中的字段类型会变为TEXT } } 如果将数据源/grails app/conf/XXXDataSource中的String dbCreate = update Grails会自动帮我们同步内存和数据库中域类对象的状态这点是很方便的不需要在每次修改对象后 update了(GORM 中的save()相当于Hibernate中的saveOrUpdate()) 其好处犹如Java 中 new出一个对象当不再使用此对象时不需要自行delete一样在实际开发中您就会体会到了下面让我们看一下GORM中的 : :N N: N:N以及继承关系映射一对一关系class Dog { String name Tail tail // 狗有一条尾巴} class Tail { float size Dog owner // 尾巴也知道自己属于那只狗}现在Dog和Tail的一对一关系是双向的当然你也可以去掉T ail类中的owner属性或Dog类中的tail属性使一对一关系变为单向的级联删除当Dog对象被删除时则Dog对象所引用的Tail对象也将被相应删除;同样地当Tail对象被删除时Tail对象所引用的Dog对象也将被相应删除如果你认为Tail被切除后Dog应该还活着即Tail 对象删除后 Tail对象所应用的Dog对象不应该被删除那么我们可以通过在Tail类中声明类变量belongsT o来实现在这个场景中我们将Tail 改为class Tail { float size Dog owner // 尾巴也知道自己属于那只狗static belongsT o = Dog // 注意是static的} 级联更新/保存当Dog对象更新/保存 Dog对象所引用的Trail对象也更新/保存;反之亦然一对多多对一关系class Dog { String name static hasMany = [feet: Foot] // 通过声明类变量hasMany 来定义Dog 一这方有多Foot } class Foot { float size Dog owner static belongsTo = Dog // 在一对多多对一关系中默认多方belongsTo 一方} 关于保存更新和删除与一对一关系相同都是级联更新/保存和级联删除当Dog被删除时由于Foot belongsT o(属于) Dog 所以Dog 对象所引用的所有Foot对象全被删除;而当Foot对象被删除时Dog 对象不会被删除这是通过类变量belongsTo实现的多对多关系class Teacher { String name static hasMany = [students: Student] } class Student { String name static hasMany = [teachers: Teacher] static belongsTo = Teacher // 在多对多关系中至少有一方声明类变量belongsTo } 更新/保存在多对多关系中相对一对一一对多多对一关系中要特殊点就是只有拥有方可以级联更新/保存比如在本例中由于Student belongsTo Teacher 所以Teacher是拥有方Teacher的更新/保存将引起Teacher对象所引用的所有Student对象的更新/保存删除也有点特殊拥有方被删除后它所引用的对象不会被删除你必须自己删除它们否则它们将成为孤儿继承关系class Base { } class Derived extends Base { }只要定义类无需任何配置够简单吧lishixinzhi/Article/program/Java/hx/201311/26540。
groovy方法
groovy方法Groovy方法Groovy是一种基于Java平台的动态语言,它具有许多Java所不具备的特性,例如闭包、元编程和DSL等。
在Groovy中,方法是一种非常重要的概念,因为所有的代码都必须放在方法中才能被执行。
本文将详细介绍Groovy中的方法相关知识。
一、定义方法在Groovy中,定义一个方法非常简单。
只需要使用关键字def加上方法名和参数列表即可。
例如:```def hello(name) {println "Hello, $name!"}```这个例子定义了一个名为hello的方法,它接受一个参数name,并在控制台输出“Hello, name!”。
需要注意的是,在Groovy中并不需要指定返回值类型,因为它会自动推断出返回值类型。
二、调用方法调用一个方法也很简单。
只需要使用方法名和参数列表即可。
例如:```hello("Tom")```这个例子调用了之前定义的hello方法,并传入了一个名为Tom的参数。
三、默认参数值在Groovy中,可以为方法设置默认参数值。
例如:```def greet(name="world") {println "Hello, $name!"}```这个例子定义了一个名为greet的方法,并设置了默认参数值为“world”。
如果调用时不传入任何参数,则会使用默认值。
四、可变参数在Groovy中,可以使用星号(*)定义可变参数。
例如:```def sum(numbers...) {def result = 0numbers.each { result += it }return result}```这个例子定义了一个名为sum的方法,并使用星号定义了一个可变参数numbers。
在方法内部,可以像操作数组一样遍历这个可变参数并进行求和。
五、命名参数在Groovy中,可以使用命名参数来传递参数。
groovy定义方法
groovy定义方法嘿呀,宝子!今天咱们来唠唠Groovy里定义方法这事儿。
在Groovy里定义方法可有意思啦。
就像你在和程序这个小伙伴讲一个新的规则一样。
比如说,你想定义一个简单的加法方法。
你可以这么写:def add(num1, num2) {return num1 + num2.}看呀,这个“def”就像是一个魔法咒语,告诉Groovy“我要开始定义个东西啦”。
然后括号里的“num1”和“num2”呢,就像是两个小盒子,用来装你要加的数字。
最后那个“return”就是把结果拿出来给大家看。
而且哦,Groovy很贴心的呢。
如果你的方法就只有一行代码,像这个加法方法,你还可以把大括号省略掉,写成这样:def add(num1, num2) = num1 + num2.是不是超级简洁呀?就像你和程序说“别整那些复杂的,简单点就好”。
要是你想定义一个方法来判断一个数是不是偶数呢?可以这样写:def isEven(num) {return num % 2 == 0.}这里的“%”就是求余数啦。
如果这个数除以2的余数是0,那就是偶数,这个方法就会返回“true”,不然就返回“false”。
还有哦,方法的名字你可以随便取,只要符合命名规则就好。
你可以取个超级有趣的名字,像“superAdd”或者“funnyIsEven”之类的。
不过呢,取个好理解的名字是很重要的啦,这样别人看你的代码就不会一头雾水。
Groovy定义方法就是这么轻松又有趣。
你可以按照自己的想法,让程序去做各种各样好玩的事情。
就像是你在指挥一群小机器人,让它们按照你的规则来玩数字游戏或者做逻辑判断。
宝子,你要是开始玩Groovy,肯定会爱上这种定义方法的感觉的啦!。
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是一种基于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⼊门教程⼀、groovy是什么简单地说,Groovy 是下⼀代的java语⾔,跟java⼀样,它也运⾏在 JVM 中。
作为跑在JVM中的另⼀种语⾔,groovy语法与 Java 语⾔的语法很相似。
同时,Groovy 抛弃了java烦琐的⽂法。
同样的语句,使⽤groovy能在最⼤限度上减少你的击键次数——这确实是“懒惰程序员们”的福⾳。
⼆、开发环境1、 jdk 1.5以上2、 eclipse+groovy plugin(⽀持Groovy 1.5.7)三、创建groovy项⽬1、新建⼀个groovy项⽬New --> Project à Java Project 创建⼀个java项⽬。
为了⽅便管理,建议在source中建两个source⽂件夹java和groovy,分别⽤于存储java 源⽂件和groovy源⽂件:2、添加 Groovy 特性在项⽬上右击,Groovy à Add Groovy Nature,这样会在项⽬中添加 Groovy Libraries。
3、添加 Groovy 类在项⽬groovy源⽂件下右键,New à Other àGroovy à Groovy Class⾃动⽣成的源代码如下:public class HelloWorld{/*** @param args*/public static void main(def args){// TODO Auto-generated method stub}}我们在main⽅法中加⼀句打印语句:println "Hello World"4、编译运⾏groovy类在源⽂件上右键,Compile Groovy File,然后右键,Run As à Groovy ,在控制台中查看运⾏结果。
实际上 groovy 语法的简练还体现在,就算整个⽂件中只有println "Hello World"这⼀句代码(把除这⼀句以外的语句删除掉吧),程序也照样能够运⾏。
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教程
Groovy教程Groovy教程admin | Groovy | 2012 年 2 月 27 日Groovy环境安装配置1.安装JDKGroovy是基于JVM的,当然,先得装个JDK了,并配置好Java 环境2.下载并安装groovy下载地址:我下载的是1.5.6 Binary Release.解压到指定目录(我的是C:\groovy),到这里groovy已经安装好了3.配置环境变量设置GROOVY_HOME —> C:\groovy将%GROOVY_HOME%\bin追加到Path里4.测试开启命令提示符窗口,输入命令groovy -v到此,Groovy环境配置成功。
注意:不用加载lib下面的jar到classpath中,groovy执行时会自动加载,在%GROOVY_HOME%\conf\groovy-starter.conf文件中已经加载了。
5.常用命令Groovy –h 帮助Groovy – v 打印使用的版本Groovy –e “脚本内容”Groovy filename 执行指定脚本文件内容Groovy –Xmx128M 可以跟java命令使用的参数…Linux安装Groovy两种方式在linux下安装groovy:1、直接通过rpm进行安装,具体步骤如下:1、输入命令 wget 下载安装文件2、使用rmp命令进行安装: rpm -ivh groovy-1.7.1-2.noarch.rpm,这里的安装是基于一定的权限的,因为会在安装包既定的目录下生成文件,所以要求具有对应目录的权限。
安装之前可以通过命名rpm -qpl groovy-1.7.1-2.noarch.rpm来查看具体文件安装的位置,如果安装不成功也可以通过该命令来查看自己是否拥有对应目录的权限。
如果顺利通过以上两部就可以安装好groovy。
当然如果由于权限的限制,可以采用第二种方式来安装。
2、直接采用二进制包手动配置安装1、输入命令 wget 下载二进制Groovy环境包2、直接采用unzip命令将下载下来的文件解压3、使用export GROOVY_HOME来设置解压目录为环境变量4、通过PATH=$PATH:$GROOVY_HOME/bin方式来设置路径以上两种安装方式都必须基于java环境已经安装配置完成,JAVA_HOME环境变量设置良好。
Groovy脚本基础全攻略
Groovy脚本基础全攻略1 背景Groovy脚本基于且拓展了Java,所以从某种程度来说掌握Java是学习Groovy的前提,故本⽂适⽤于不熟悉Groovy却想快速得到Groovy核⼼基础⼲货的Java开发者(注意是Java),因为我的⽬的不是深⼊学习Groovy语⾔,所以本⽂基本都是靠代码来解释,这样最直观,同时也够⼲货基础⼊门Groovy的特点和结构。
开始介绍前先给⼀个⼤法,英⽂好的可以直接略过本⽂后续内容,我需要的只是Groovy⽪⽑;再次向Groovy的标志致敬,左⼿⼀个Java,右⼿⼀个Groovy,不好意思,我技术⽔平太Low了(T–T__《琅琊榜》看多了)。
Groovy是⼀种动态语⾔,它和Java类似(算是Java的升级版,但是⼜具备脚本语⾔的特点),都在Java虚拟机中运⾏。
当运⾏Groovy脚本时它会先被编译成Java类字节码,然后通过JVM虚拟机执⾏这个Java字节码类。
快速安装指南:安装Groovy在各种Bash下都是通⽤的,具体如下命令就可搞定:$ curl -s get.sdkman.io | bash$ source "$HOME/.sdkman/bin/sdkman-init.sh"$ sdk install groovy$ groovy -version//⾄此就可以享⽤了!我们在写Groovy代码时可以直接使⽤⾃⼰喜欢的⽂本编辑器编辑OK以后以.groovy后缀保存,然后在终端执⾏如下命令即可运⾏:$ groovy ./TestFile.groovy或者我们可以通过groovyConsole来进⾏groovy代码开发运⾏(由于不需要特别深⼊学习使⽤Groovy,所以个⼈⾮常喜欢这种模式的开发运⾏),如下图:再或者我们还可以使⽤Intellij IDEA等⼯具安装groovy插件进⾏groovy开发,这⾥不再⼀⼀叙述了(),直接给出⼀个读取指定⽂件内容打印的例⼦,如下:OK,有了上⾯这些简单粗暴的基础和环境之后那我们快速开战吧。
Groovy编程基础教程
Groovy编程基础教程第一章:Groovy简介与安装Groovy是一种基于Java的编程语言,旨在提供更简单、更灵活的编程体验。
本章将介绍Groovy的背景和特点,并提供安装Groovy的步骤和指南。
首先,可以了解Groovy的历史和与Java的关系。
接下来,详细介绍如何从Groovy官方网站上下载和安装Groovy,并配置所需的环境变量。
最后,通过一个简单的Hello World程序,确保Groovy已正确安装并可运行。
第二章:Groovy语法本章将介绍Groovy的语法规则和基本结构。
首先,对比Java和Groovy的语法差异,强调Groovy在简化代码书写方面的优势。
然后,详细介绍Groovy的变量和数据类型,包括字符串、数字和集合。
接着,讲解Groovy的控制流语句,如条件语句和循环语句。
最后,介绍如何在Groovy中定义和使用函数,并探讨闭包的概念。
第三章:面向对象编程与Groovy本章将探讨如何在Groovy中使用面向对象编程的思想和特性。
首先,介绍类和对象的概念,以及如何在Groovy中定义类和创建对象。
然后,介绍如何实现继承和多态,以及在Groovy中的具体应用。
接下来,介绍在Groovy中如何处理异常和错误,并展示常见的错误处理模式。
最后,探讨如何使用Groovy的元编程能力来扩展现有的类和方法。
第四章:Groovy与Java的交互本章将重点介绍Groovy与Java之间的交互方式。
首先,讨论如何在Groovy中引用和使用Java类和库。
接着,介绍如何使用Groovy的@Grab注解来动态加载和使用Java库。
然后,介绍如何在Groovy中调用Java类的方法,以及如何处理Java异常。
最后,介绍如何在Groovy中编写JavaBean和接口,并与Java代码进行交互。
第五章:Groovy脚本编程本章将介绍Groovy脚本编程的基础知识和技巧。
首先,介绍Groovy脚本的特点和用途,以及如何编写和运行Groovy脚本。
groovy写方法
groovy写方法Groovy是一种基于Java平台的动态语言,它具有简洁、易读、易写的特点,同时也支持面向对象、函数式编程等多种编程范式。
在Groovy中,我们可以使用闭包来定义方法,这种方法定义方式非常灵活,可以让我们更加方便地编写代码。
本文将介绍如何使用Groovy来编写方法。
一、Groovy方法的定义在Groovy中,我们可以使用def关键字来定义方法,例如:```def add(int a, int b) {return a + b}```这个方法的名字是add,它接受两个int类型的参数a和b,返回它们的和。
在Groovy中,方法的返回值可以使用return语句来指定,也可以省略return语句,此时方法的返回值就是最后一行语句的值。
二、Groovy方法的参数Groovy方法的参数可以使用类型声明,也可以不使用类型声明。
例如:```def greet(name) {println "Hello, $name!"}```这个方法的名字是greet,它接受一个参数name,这个参数没有类型声明。
在方法内部,我们可以使用$name来引用这个参数。
如果我们想要使用类型声明,可以这样写:```def greet(String name) {println "Hello, $name!"}```这个方法的参数name是一个String类型的参数。
在Groovy中,方法的参数可以使用默认值,例如:```def greet(String name = "world") {println "Hello, $name!"}```这个方法的参数name有一个默认值"world",如果我们不传递参数,它就会使用默认值。
三、Groovy方法的闭包参数在Groovy中,我们可以使用闭包作为方法的参数,例如:```def repeat(int n, Closure action) {for (int i = 0; i < n; i++) {action.call(i)}}```这个方法的名字是repeat,它接受两个参数:一个int类型的参数n和一个Closure类型的参数action。
Groovy中文教程
2. Groovy for the Java Eyes
在这章我会帮助你轻松的认识 Groovy. 首先,从熟悉的 Java 然后再转换到 Groovy 的写法。 由于 Groovy 保留 Java 语法和语义, 你可以随时混合 Java 样式 和 Groovy 样式.现在开始我们 的 Groovy 之旅.
// Java code public class Greetings { public static void main(String[] args) { for(int i = 0; i < 3; i++) { System.out.print("ho " ); } System.out.println("Merry Groovy!" ); } }
开始 Groovy
1. 使用入门
你可能急着的编写一些 Groovy 代码, 对吧? 好的, 首先,你必须安装 Groovy. 在这章, 我将告 诉你如何快速安装 Groovy 并确保一切在你的系统上运行良好.
1.1 使用 Groovy
获取稳定的 Groovy 版本非常简单:只要浏览 Groovy 主页 , 点击 Download 链接。 你可以下载 binary release 或者 source release。 假如你想在自己的电脑上 构建 Groovy 或者想研究它的源代码可以下载 source release。否则, 推荐你下载 binary release (假如你使用的是 Windows, 你可以下载 Windows 安装版本, 但我建议获取 binary release 自己 来设置必要的环境)。 同时你需要 JDK 1.4 或最新的(see /javase/downloads/ index.jsp). 假如你想体验 Groovy 内 Java 5 支持功能 ,我建议至少 JDK 1.5。最后,确定你 已经安装了 Java 。
Groovy轻松入门
Groovy轻松入门——搭建Groovy开发环境 (1)Groovy轻松入门——通过与Java的比较,迅速掌握Groovy (更新于2007.09.23) (2)Groovy轻松入门——Grails实战之遗留框架利用篇 (52)Groovy轻松入门——搭建Groovy开发环境既然是入门,我先不介绍那些IDE的东西,比如Eclipse中的Groovy插件(如果您迫不及待的话,可以先看一下安装Groovy的Eclipse插件),我先讲一下如何设置Groovy的环境变量(我目前所用的系统是Windows XP),最后运行一个Hello, world程序告终。
Groovy既然是Java帝国的王储,当然少不了Java的支持。
0,先安装JDK(推荐版本为1.5及1.5以上,当然1.4也可以)然后设置Java的环境变量:1,设置环境变量java_home(设置环境变量XXX_home的一个好处是只要修改XXX_home的值,与之相关的%XXX_home%\bin等的值都相应改变,这样就能做到…一处修改,处处修改‟)右击…我的电脑‟-> …属性‟ ->…高级‟-> …环境变量‟-> 点击…新建‟(用户变量与系统变量均可,挑一便是)-> 输入…变量名‟为java_home -> 输入…变量值‟为JDK的所在目录(默认安装位置为C:\ProgramFiles\Java\jdk1.6.0,我装的是JDK6.0)-> 点击…确定‟-> 环境变量java_home设置成功2,设置环境变量path环境变量java_home设置好之后,我们开始设置环境变量path前面的步骤与…设置环境变量java_home‟相同,到点击…新建‟按钮时,选择新建用户变量(因为系统变量path已经存在,如果追加在长串已存在的path值后面,比较凌乱) -> 输入…变量名‟为path -> 输入…变量值‟为“%java_home%\bin;” 不包括双引号“”3,设置环境变量classpath环境变量path设置好之后,我们开始设置环境变量classpath前面的步骤与…设置环境变量java_home‟相同,到点击…新建‟按钮时,选择新建系统变量(我的个人习惯,你也可以选择新建用户变量)-> 输入…变量名‟为classpath -> 输入…变量值‟为“.;%java_home%\lib;”不包括双引号“”,注意不要漏了最前面的小圆点.如果你已经安装了JDK,并设置好了Java环境变量,请跳过上述过程,直接安装GDK(只需3步)(如果您下载的是Groovy安装版Download Windows-Installer: BinaryRelease /Download,请将安装过程中出现的选项都打上勾,以下4,5,6步骤可以跳过)请留意朝花夕拾——Groovy & Grails中的Groovy最新稳定版的版本号4,下载GDK (/groovy/distributions/groovy-1.0.zip)并将下载的groovy-1.0.zip文件解压到指定位置(我的位置是D:\D\MY_DEV\groovy),5,设置环境变量GROOVY_HOME步骤与“设置环境变量java_home”类似,到输入…变量名‟时,输入…GROOVY_HOME‟-> 输入…变量值‟为你解压指定位置(我的变量值为D:\D\MY_DEV\groovy),需要注意一点,解压目录如D:\D\MY_DEV\groovy中不可有空格,比如D:\D\MY DEV\groovy6,将GROOVY_HOME目录下的bin追加到环境变量path中步骤与“设置环境变量path”类似,找到你设置的path,然后将“%GROOVY_HOME%\bin”追加到path值(按上述过程,你现在的path为“%java_home%\bin;”)之后,你的path值为“%java_home%\bin;%GROOVY_HOME%\bin” ,注意用英文分号;分开,不要有空白字符如空格,Tab 等最后,我想提醒大家的是,不要将GROOVY_HOME目录下的jar包(比如GROOVY_HOME\embeddable\groovy-all-1.0.jar)添加到环境变量classpath中,因为Groovy自己会将GROOVY_HOME\lib下的所有jar文件(其中包括了Groovy相关的jar文件,如groovy-1.0.jar)添加到Groovy的classpath中,而groovy同样会用Java的classpath(系统变量中的classpath),如果将Groovy相关jar文件如groovy-all-1.0.jar添加到环境变量classpath中,jar文件会产生冲突,今后的Groovy生活(如利用Grails方便快捷地开发Web应用)就将成为泡影 :)好了,现在请大家打开Windows下的dos,即…命令行‟,在那个黑底白字的窗口中输入“groovyConsole”,回车,过一会儿就会出现一个GroovyConsole的窗口,在上面的文本域中,输入println 'Hello, world!' // 打印Hello, world!然后按Ctrl + R 来运行你的第一个Hello, world程序,在下面的窗口中便可看到运行结果:Hello, world! 祝贺你,第一个Groovy程序运行成功!Groovy轻松入门——通过与Java的比较,迅速掌握Groovy在前几篇文章中,我已经向大家介绍了Groovy是什么,学习Groovy的重要性等内容,还不了解Groovy 的朋友不妨去看看我Blog中的Groovy分类。
Groovy入门教程
Collection支持集合运算: println collect[collect.size()-1] collect=collect-'a' //在集合中减去元素a(第1个) println collect[0] //现在第1个元素变成b了 同样地,你可以往集合中添加另一个集合或删除一个集合: collect=collect-collect[0..4] //把集合中的前5个元素去掉 println collect[0] //现在集合中仅有一个元素,即原来的最后一个元素 println collect[-1] //也可以用负索引,证明最后一个元素就是第一个元素 (2) Map Map 是“键-值”对的集合,在groovy 中,键不一定是String ,可以是任何对象(实际上Groovy中的Map 就 是java.util.LinkedHashMap)。 如此可以定义一个Map: def map=['name':'john','age':14,'sex':'boy'] 添加项: map=map+['weight':25] map.put('length',1.27) map.father='Keller' 可以用两种方式检索值: println map['father'] println map.length 11 、 //通过key作为下标索引 //通过key作为成员名索引 //添加john的体重 //添加john的身高 //添加john的父亲
Groovy入门教程 Groovy
首页
问答
知识库
圈子
广告服务
搜索
Groovy安装与入门实例
Groovy安装与⼊门实例摘⾃:1 Groovy是什么?来看下官⽹的介绍:Groovy...· is an agile and dynamic language for the Java Virtual Machine · builds upon the strengths of Javabut has additionalpower features inspiredby languages like Python, Ruby and Smalltalk · makes modern programming features available to Java developers with almost-zero learning curve· provides the ability to statically type check and staticallycompile your codefor robustness and performance · supports Domain-Specific Languages and other compact syntax so your codebecomes easyto read and maintain· makes writing shell and buildscripts easy with its powerfulprocessing primitives, OO abilities and an Ant DSL · increases developer productivity by reducing scaffolding code when developing web, GUI, database orconsole applications· simplifies testing bysupporting unit testing and mocking out-of-the-box· seamlessly integrates with all existingJava classes and libraries· compiles straight to Java bytecodeso you can use it anywhere you can use Java通过⽀持DSL提⾼代码可读性和可维护性减少开始Web、GUI、数据库、控制台应⽤程序时的脚⼿架代码简化单元测试和Mock技术与Java类包⽆缝集成2 Groovy环境安装下⾯是官⽅⽂档中摘取的安装步骤。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Groovy 快速入门1、集合 、 (1)List (java.util.List) ) list = [1, 2, 'hello', new java.util.Date()] assert list.size() == 4 assert list.get(2) == 'hello' 注意:一切都是对象(数字会自动转换) (2)Map (java.util.Map) ) map = ['name':'James', 'location':'London'] assert map.size() == 2 assert map.get('name') == 'James' (3)遍历集合 ) list = [1, 2, 3] for (i in list) { println i } 2、闭包(Closures) 、闭包( ) 闭包类似 Java 的内类,区别是闭包只有单一的方法可以调用,但可以有任意的参数 closure = { param | println("hello ${param}") } closure.call("world!") closure = { greeting, name | println(greeting + name) } closure.call("hello ", "world!") 闭包用“{}”括起,“|”前面是参数,后面是处理语句,使用 call 调用 这里我们使用了一个 Groovy-Beta3 闭包定义, 只是为了让您能看懂老版本 Groovy 的一些例子。
在 新的 Groovy JSR 中对闭包的定义略有改动, 因为 | 字符同时也是 Java 中的位操作符; Groovy JSR 建议使用 Nice (另外一种 JRE 语言)样式的 -> 分隔符代替它。
第一个例子演示了在字符串内使用参数的形式:${param} 第二个例子演示了多参数形式:用“,”分隔参数 如果只有一个参数,可以不写,而使用缺省的参数“it”,如下面的例子: closure = { println "hello " + it } closure.call("world!") 3、each 、 遍历集合,逐个传递给闭包[1, 2, 3].each { item | print "${item}-" } 上面例子的输出结果是:1-2-3-4、collect 、 遍历集合,逐个传递给闭包,处理后的结果返回给对应的项value = [1, 2, 3].collect { it * 2 } assert value == [2, 4, 6] 5、find 、 根据闭包断言,返回集合中找到的第一个项目value = [1, 2, 3].find { it > 1 } assert value == 2 6、findAll 、 根据闭包断言,返回集合中所有找到的项目value = [1, 2, 3].findAll { it > 1 } assert value == [2, 3] 7、inject 、 遍历集合,第一次将传递的值和集合项目传给闭包,将处理结果作为传递的值,和下一个 集合项目传给闭包,依此类推 value = [1, 2, 3].inject('counting: ') { str, item | str + item } assert value == "counting: 123" value = [1, 2, 3].inject(0) { count, item | count + item } assert value == 6 8、every 、 如果集合中所有项目都匹配闭包断言,就返回 true,否则返回 falsevalue = [1, 2, 3].every { it < 5 } assert valuevalue = [1, 2, 3].every { item | item < 3 } assert ! value 9、any 、 如果集合中任何项目匹配闭包断言,就返回 true,否则返回 falsevalue = [1, 2, 3].any { it > 2 } assert value value = [1, 2, 3].any { item | item > 3 }assert value == false 10、min/max 、 返回集合中的最小/最大项目(对象必须可比较) value = [9, 4, 2, 10, 5].max() assert value == 10 value = [9, 4, 2, 10, 5].min() assert value == 2 value = ['x', 'y', 'a', 'z'].min() assert value == 'a' 11、join 、 连接集合中的值成一个字符串value = [1, 2, 3].join('-') assert value == '1-2-3' 12、 yield 、 在 Python 和 Ruby 中通过 yield 语句创建“yield”风格的 iterators,在 Groovy 同样有效,只是 使用的是闭包 class Foo{ static void main(args) { foo = new Foo() for (x in foo.myGenerator) { print("${x}-") } } myGenerator(Closure yield) { yield.call("A") yield.call("B") yield.call("C") } } 例子的输出结果是:A-B-CCloures 原型可以省略,call 和括号同样可选,这样更象 Python/Rubyclass Foo { myGenerator(yield) { yield "A" yield "B" yield "C" } static void main(args) {foo = new Foo() foo.myGenerator { println "Called with ${it}" } } }Groovy 全攻略 嵌入篇 全攻略--嵌入篇 Groovy 被设计得非常轻量级,很容易迁入到任何 Java 应用系统。
你可以使用 BSF 将 Groovy 脚本嵌入任何 Java 代码中.但是 Groovy 提供了一个轻量级的紧密集成. 下面是 3 种主要方法:1.使用 Shell 调试脚本或表达式 在 Groovy 中你可以使用 GroovyShell 对 Groovy 脚本和表达式进行调试.GroovyShell 允许你通过 Binding 对象传入或传出变量. // 从 Java 代码中调用 Groovy 语句 Binding binding = new Binding(); binding.setVariable("foo", new Integer(2)); GroovyShell shell = new GroovyShell(binding);Object value = shell.evaluate("println 'Hello World!'; x = 123; return foo * 10"); assert value.equals(new Integer(20)); assert binding.getVariable("x").equals(new Integer(123));2.在 Java 中动态调用运行 Groovy 代码 你可以使用 GroovyClassLoader 将 Groovy 的类动态地载入到 Java 程序中并直接使用或运行它. 下面是一个例子: ClassLoader parent = getClass().getClassLoader(); GroovyClassLoader loader = new GroovyClassLoader(parent); Class groovyClass = loader.parseClass(new File("src/test/groovy/script/HelloWorld.groovy"));// 调用实例中的某个方法 GroovyObject groovyObject = (GroovyObject) groovyClass.newInstance(); Object[] args = {};groovyObject.invokeMethod("run", args);如果你想使用一个用 Groovy 脚本实现的接口,你可以这么使用它: GroovyClassLoader gcl = new GroovyClassLoader(); Class clazz = gcl.parseClass(myStringwithGroovyClassSource "SomeName.groovy"); Object aScript = clazz.newInstance(); MyInterface myObject = (MyInterface) aScript; myObject.interfaceMethod();如果某个 Groovy 类实现口 MyInterface 接口,那么上面的代码就会很好的工作.myObject 的使用方法 与其他实现了 MyInterface 接口的 Java 对象一样.3.Groovy 脚本引擎 对于那些想将 Groovy 脚本嵌入到服务器并且在每次修改后重新装入的人来说,Groovy 脚本引擎提供 了一个彻底的解决方案.你可以设定系列 CLASSPATH 作为根来初始化 Groovy 脚本引擎,这些 GLASSPATH 可以是 URL 也可以是目录名.接着你就可以这些根路径下的任何 Groovy 脚本了.GSE 会跟踪脚本间的依赖关系,因此如果任何有依赖关系的脚本被修改,整颗树将会重新编译和载入. 另外,每次执行脚本时,你都可以传入一个包含脚本可接受属性的 Binding.脚本执行完以后,传入脚本 中的那些属性在 Binding 中依然有效.下面是一个例子: /my/groovy/script/path/hello.groovy: output = "Hello, ${input}!"import ng.Binding; import groovy.util.GroovyScriptEngine;String[] roots =new String[] { " /my/groovy/script/path " } ; new GroovyScriptEngine(roots);GroovyScriptEngine gse = Binding binding =new Binding();binding.setVariable( " input " , " world " );gse.run( " test.groovy " , binding); System.out.println(binding.getVariable( " output " )); 将打印 "Hello, world!".4.运行时依赖 和 JDK1.4 一样,Groovy Jar 也依赖与 ASM 库上的运行时,ASM 库包括 4 个 Jar(asm-2.1.jar, asm-util-2.1.jar, asm-attrs-2.1.jar and asm-analysis-2.1). 也就是说,只要将上面的 5 个 Jar 添加到路径中, 你就能将轻松地 Groovy 嵌入到你的应用里.另一种方案可以不用那么多的 Jar.你可以用 GROOVY_HOME/embeddable 目录下的 groovy-all-1.0-beta-x.jar.这个 Jar 包将 Groovy 和 ASM 组合打包成一个方便的 Jar 包.注 意:groovy-all-1.0-beta-x.jar 中的 ASM 类使用了不同的命名空间,因此要避免与使用 ASM 的库发生冲 突.Groovy 全攻略 运行篇 全攻略--运行篇 Groovy 脚本是一个包含许多语句和类声明的文本文件.Groovy 的用法和其他脚本语言类似.下面是 几种运行 Groovy 脚本的方法: 1.使用交互控制台 Groovy 有一个 Swing 交互控制台,允许你像使用 SQL 工具一样输入和执行 Groovy 语句.控制台支持 历史记录,因此你可以向前或向后遍历命令. 如果你已经安装了 Groovy 二进制分发包,你可以使用下面的命令启动 Groovy Swing 控制台. 如果像启动命令行控制台,可以输入下面的命令: GroovyConsole如果想启动命令行控制台,可以输入下面的命令 Groovysh从源代码分发包中启动 Swing Groovy 控制台 maven console2.通过 IDE 运行 Groovy 脚本 有一个叫做 GroovyShell 的类含有 main(String[])方法可以运行任何 Groovy 脚本.你可以用下面的语 句执行任何 Groovy 脚本: java ng.GroovyShell foo/MyScript.groovy [arguments 你可以在你的 IDE 中使用上面的 Groovy main()执行或调试任何 Groovy 脚本.3.用命令行执行 Groovy 脚本 在 GROOVY_HOME\bin 里有个叫'groovy' 或'groovy.bat' 的脚本文件(或者二者都有,根据你的平台 不同而不同).这些脚本文件是 Groovy 运行时的一部分. 一旦安装了 Groovy 运行时,你就可以这样运行 Groovy 脚本: groovy foo/MyScript.groovy [arguments] 如果你使用从 CVS 构建的 Groovy,那么除了 Groovy 脚本以外,命令行上可能还运行着其他的类. 1.拥有 main()方法的类; 2.和 JUnit 的测试一起运行的继承自 GroovyTestCase 的类, 3.实现 Runnable 接口的类.run()方法被调用. 获得最新最强的 Groovy,输入下面的命令做一个 CVS 检出 maven groovy:make-install 在 groovy/target/install 里会有一份完整的二进制分发包.你可以将 groovy/target/install/bin 添加到你的 路径,这样你就可以轻松地用命令行执行你的 Groovy 脚本了.4.用 Groovy 创建 Unix 脚本 你可以用 Groovy 编写 Unix 脚本并且像 Unix 脚本一样直接从命令行运行它.倘若你安装的是二进制 分发包并且设置好了路径,那么下面的代码将会很好的工作: 将其保存为 helloWorld.groovy. #!/usr/bin/env groovy println("Hello world") for (a in this.args) { println("Argument: " + a) } 接着从命令行运行这个脚本,chmod +x helloWorld ./helloWorld。