加载中...

Groovy

其中 Y=Groovy

源代码下载： learngroovy-cn.groovy

Groovy - Java平台的动态语言。了解更多。

  1. /*
  2.   安装：
  4.   1) 安装 GVM - http://gvmtool.net/
  5.   2) 安装 Groovy： gvm install groovy
  6.   3) 启动 groovy 控制台，键入： groovyConsole
  8. */
  10. //  双斜线开始的是单行注释
  11. /*
  12. 像这样的是多行注释
  13. */
  15. // Hello World
  16. println "Hello world!"
  18. /*
  19.   变量：
  21.   可以给变量赋值，以便稍后使用
  22. */
  24. def x = 1
  25. println x
  27. x = new java.util.Date()
  28. println x
  30. x = -3.1499392
  31. println x
  33. x = false
  34. println x
  36. x = "Groovy!"
  37. println x
  39. /*
  40.   集合和映射
  41. */
  43. //创建一个空的列表
  44. def technologies = []
  46. /*** 往列表中增加一个元素 ***/
  48. // 和Java一样
  49. technologies.add("Grails")
  51. // 左移添加，返回该列表
  52. technologies << "Groovy"
  54. // 增加多个元素
  55. technologies.addAll(["Gradle","Griffon"])
  57. /*** 从列表中删除元素 ***/
  59. // 和Java一样
  60. technologies.remove("Griffon")
  62. // 减号也行
  63. technologies = technologies - 'Grails'
  65. /*** 遍历列表 ***/
  67. // 遍历列表中的元素
  68. technologies.each { println "Technology: $it"}
  69. technologies.eachWithIndex { it, i -> println "$i: $it"}
  71. /*** 检查列表内容 ***/
  73. //判断列表是否包含某元素，返回boolean
  74. contained = technologies.contains( 'Groovy' )
  76. // 或
  77. contained = 'Groovy' in technologies
  79. // 检查多个元素
  80. technologies.containsAll(['Groovy','Grails'])
  82. /*** 列表排序 ***/
  84. // 排序列表（修改原列表）
  85. technologies.sort()
  87. // 要想不修改原列表，可以这样：
  88. sortedTechnologies = technologies.sort( false )
  90. /*** 列表操作 ***/
  92. //替换列表元素
  93. Collections.replaceAll(technologies, 'Gradle', 'gradle')
  95. //打乱列表
  96. Collections.shuffle(technologies, new Random())
  98. //清空列表
  99. technologies.clear()
  101. //创建空的映射
  102. def devMap = [:]
  104. //增加值
  105. devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
  106. devMap.put('lastName','Perez')
  108. //遍历映射元素
  109. devMap.each { println "$it.key: $it.value" }
  110. devMap.eachWithIndex { it, i -> println "$i: $it"}
  112. //判断映射是否包含某键
  113. assert devMap.containsKey('name')
  115. //判断映射是否包含某值
  116. assert devMap.containsValue('Roberto')
  118. //取得映射所有的键
  119. println devMap.keySet()
  121. //取得映射所有的值
  122. println devMap.values()
  124. /*
  125.   Groovy Beans
  127.   GroovyBeans 是 JavaBeans，但使用了更简单的语法
  129.   Groovy 被编译为字节码时，遵循下列规则。
  131.     * 如果一个名字声明时带有访问修饰符（public, private, 或者 protected），
  132.       则会生成一个字段（field）。
  134.     * 名字声明时没有访问修饰符，则会生成一个带有public getter和setter的
  135.       private字段，即属性（property）。
  137.     * 如果一个属性声明为final，则会创建一个final的private字段，但不会生成setter。
  139.     * 可以声明一个属性的同时定义自己的getter和setter。
  141.     * 可以声明具有相同名字的属性和字段，该属性会使用该字段。
  143.     * 如果要定义private或protected属性，必须提供声明为private或protected的getter
  144.       和setter。
  146.     * 如果使用显式或隐式的 this（例如 this.foo, 或者 foo）访问类的在编译时定义的属性，
  147.       Groovy会直接访问对应字段，而不是使用getter或者setter
  149.     * 如果使用显式或隐式的 foo 访问一个不存在的属性，Groovy会通过元类（meta class）
  150.       访问它，这可能导致运行时错误。
  152. */
  154. class Foo {
  155.     // 只读属性
  156.     final String name = "Roberto"
  158.     // 只读属性，有public getter和protected setter
  159.     String language
  160.     protected void setLanguage(String language) { this.language = language }
  162.     // 动态类型属性
  163.     def lastName
  164. }
  166. /*
  167.   逻辑分支和循环
  168. */
  170. //Groovy支持常见的if - else语法
  171. def x = 3
  173. if(x==1) {
  174.     println "One"
  175. } else if(x==2) {
  176.     println "Two"
  177. } else {
  178.     println "X greater than Two"
  179. }
  181. //Groovy也支持三元运算符
  182. def y = 10
  183. def x = (y > 1) ? "worked" : "failed"
  184. assert x == "worked"
  186. //for循环
  187. //使用区间（range）遍历
  188. def x = 0
  189. for (i in 0 .. 30) {
  190.     x += i
  191. }
  193. //遍历列表
  194. x = 0
  195. for( i in [5,3,2,1] ) {
  196.     x += i
  197. }
  199. //遍历数组
  200. array = (0..20).toArray()
  201. x = 0
  202. for (i in array) {
  203.     x += i
  204. }
  206. //遍历映射
  207. def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
  208. x = 0
  209. for ( e in map ) {
  210.     x += e.value
  211. }
  213. /*
  214.   运算符
  216.   在Groovy中以下常用运算符支持重载：
  217.   http://www.groovy-lang.org/operators.html#Operator-Overloading
  219.   实用的groovy运算符
  220. */
  221. //展开（spread）运算符：对聚合对象的所有元素施加操作
  222. def technologies = ['Groovy','Grails','Gradle']
  223. technologies*.toUpperCase() // 相当于 technologies.collect { it?.toUpperCase() }
  225. //安全导航（safe navigation）运算符：用来避免NullPointerException
  226. def user = User.get(1)
  227. def username = user?.username
  229. /*
  230.   闭包
  231.   Groovy闭包好比代码块或者方法指针，它是一段代码定义，可以以后执行。
  233.   更多信息见：http://www.groovy-lang.org/closures.html
  234. */
  235. //例子：
  236. def clos = { println "Hello World!" }
  238. println "Executing the Closure:"
  239. clos()
  241. //传参数给闭包
  242. def sum = { a, b -> println a+b }
  243. sum(2,4)
  245. //闭包可以引用参数列表以外的变量
  246. def x = 5
  247. def multiplyBy = { num -> num * x }
  248. println multiplyBy(10)
  250. // 只有一个参数的闭包可以省略参数的定义
  251. def clos = { print it }
  252. clos( "hi" )
  254. /*
  255.   Groovy可以记忆闭包结果 [1][2][3]
  256. */
  257. def cl = {a, b ->
  258.     sleep(3000) // 模拟费时操作
  259.     a + b
  260. }
  262. mem = cl.memoize()
  264. def callClosure(a, b) {
  265.     def start = System.currentTimeMillis()
  266.     mem(a, b)
  267.     println "Inputs(a = $a, b = $b) - took ${System.currentTimeMillis() - start} msecs."
  268. }
  270. callClosure(1, 2)
  271. callClosure(1, 2)
  272. callClosure(2, 3)
  273. callClosure(2, 3)
  274. callClosure(3, 4)
  275. callClosure(3, 4)
  276. callClosure(1, 2)
  277. callClosure(2, 3)
  278. callClosure(3, 4)
  280. /*
  281.   Expando
  283.   Expando类是一种动态bean类，可以给它的实例添加属性和添加闭包作为方法
  285.   http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
  286. */
  287.   def user = new Expando(name:"Roberto")
  288.   assert 'Roberto' == user.name
  290.   user.lastName = 'Pérez'
  291.   assert 'Pérez' == user.lastName
  293.   user.showInfo = { out ->
  294.       out << "Name: $name"
  295.       out << ", Last name: $lastName"
  296.   }
  298.   def sw = new StringWriter()
  299.   println user.showInfo(sw)
  301. /*
  302.   元编程(MOP)
  303. */
  305. //使用ExpandoMetaClass增加行为
  306. String.metaClass.testAdd = {
  307.     println "we added this"
  308. }
  310. String x = "test"
  311. x?.testAdd()
  313. //拦截方法调用
  314. class Test implements GroovyInterceptable {
  315.     def sum(Integer x, Integer y) { x + y }
  317.     def invokeMethod(String name, args) {
  318.         System.out.println "Invoke method $name with args: $args"
  319.     }
  320. }
  322. def test = new Test()
  323. test?.sum(2,3)
  324. test?.multiply(2,3)
  326. //Groovy支持propertyMissing，来处理属性解析尝试
  327. class Foo {
  328.    def propertyMissing(String name) { name }
  329. }
  330. def f = new Foo()
  332. assertEquals "boo", f.boo
  334. /*
  335.   类型检查和静态编译
  336.   Groovy天生是并将永远是一门动态语言，但也支持类型检查和静态编译
  338.   更多： http://www.infoq.com/articles/new-groovy-20
  339. */
  340. //类型检查
  341. import groovy.transform.TypeChecked
  343. void testMethod() {}
  345. @TypeChecked
  346. void test() {
  347.     testMeethod()
  349.     def name = "Roberto"
  351.     println naameee
  353. }
  355. //另一例子
  356. import groovy.transform.TypeChecked
  358. @TypeChecked
  359. Integer test() {
  360.     Integer num = "1"
  362.     Integer[] numbers = [1,2,3,4]
  364.     Date date = numbers[1]
  366.     return "Test"
  368. }
  370. //静态编译例子
  371. import groovy.transform.CompileStatic
  373. @CompileStatic
  374. int sum(int x, int y) {
  375.     x + y
  376. }
  378. assert sum(2,5) == 7

进阶资源

Groovy文档

Groovy web console

加入Groovy用户组

图书

[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/ [2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize [3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html

还没有评论.