本人使用的是AS开发，所以环境搭建很简单
Mac下执行：brew install groovy
项目下：
build.gradle in project add:
classpath 'org.codehaus.groovy:gradle-groovy-android-plugin:0.3.6'
build.gradle in app add:
compile 'org.codehaus.groovy:groovy:2.4.0:grooid'
下面是学习中写的代码：
基本语法
package com.example
public class test1 {
public static void main(String[] args) {
// for (int i =0 ;i < 5;i++) { //for循环
// System.out.print("中国" + i)
// }
// System.out.print("over")
// //中国0中国1中国2中国3中国4over
// for (i in 0..10) { //for 循环
// print(i)
// } //012345678910
// 0.upto(2) { //从n(0)到m（2）
// print("$it") // it 是闭包的默认参数
// } // 012v
// 3.times { //从0到m（2）
// print("$it") // it 是闭包的默认参数
// } //012
// 0.step(10,2) { //从0到10 ，每次循环步长为2
// print("$it")
// } //02468
// println "pwd".execute().text //命令输出
// def fooPattern = /.*foo.*/
// assert fooPattern == '.*foo.*'
// def foo = /"china"/ // 可以在斜线表达式中,直接使用引号
// println foo // 结果是“china”
// println foo("evil")
// println foo(null)
// try {
// openFile("null")
// } catch (ex) {
// println ex
// }
// Car car = new Car('2017')
// println "YEAR : ${car.year}" //打印时的$可以不加括号
// println("MILES : $car.miles")
// def name1 = "china1" //返回为多结果时可以多赋值，以 （） 分别赋值 ，这里可以作为交换变量使用
// def name2 = "china2"
// println("$name1 , $name2")
// (name1,name2) = [name2,name1]
// println "$name1 , $name2"
}
// def static foo(str) { //?. 判空
// str?.reverse()
// }
// def static openFile(fileName) { //异常处理默认throw了
// new FileInputStream(fileName)
// }
// static class Car {
// def miles = 1
// def year
//
//// Car(thisYear){ //可以去掉自己的构造方法，使用灵活初始化 Car car = new Car(year:'2017')
//// year = thisYear
//// }
// }
}
注解
package com.example
//计算器 注解
public class test3 {
@Newify(ComplexNumber) //取代new的一种方式，可以直接使用 ComplexNumber(real: 1,imaginary: 1)
public static void main(String[] args) {
def c1 = new ComplexNumber(real: 1,imaginary: 2)
def c2 = new ComplexNumber(real: 4,imaginary: 1)
// def c3 = ComplexNumber.instance
println c1 + c2 //plus 对应 + minus 对应 - multiply 对应 * div 对应 ／
println c1 - c2
println c1 * c2
println c1 / c2
// @Delegate //委托类操作 ，方便好用
// @Immutable //不可变的 同java的final 可以做线程安全使用
// @Lazy //懒加载，类似单例模式中的懒加载，只有用到时才进行创建
println ComplexNumber.new(real: 1,imaginary: 1)
}
// @Canonical(excludes = "") //调用println 回去找toString方法，使用此注解可以不用自己写toString方法了
// @Singleton(lazy = true) //单例模式注解 简化使用方式
static class ComplexNumber {
def real,imaginary
def plus(other) {
new ComplexNumber(real :real+other.real, imaginary: imaginary+other.imaginary )
}
def minus(o) {
new ComplexNumber(real: 99,imaginary: 99)
}
def multiply(o) {
new ComplexNumber(real: 999,imaginary: 999)
}
def div(o) {
new ComplexNumber(real: 9999,imaginary: 9999)
}
String toString() { //默认调用toString方法
"$real ${imaginary >0?"+":''} ${imaginary}i"
}
}
}
package com.example
//闭包是一个函数 匿名函数指针 ，将部分实现逻辑委托出去
public class test4 {
public static void main(String[] args) {
// pickEvent(10) {
//当闭包在最后时可以直接放到括号外边代码块中
// str, param -> println param
// println it
// }
//curry 使用
// def multiply = { x, y -> return x * y } // closure
// def triple = multiply.curry(3) // triple = { y -> return 3 * y }
// def quadruple = multiply.curry(4) // quadruple = { y -> return 4 * y }
// def p = triple.call(4) // explicit call
// def q = quadruple(5) // implicit call
// println "p: ${p}" // p is 12
// println "q: ${q}" // q is 20
//尾递归的方式 ,尾递归不会一直保存栈信息，只需要覆盖即可
//如果一个函数中所有递归形式的调用都出现在函数的末尾，我们称这个递归函数是尾递归的。
// 当递归调用是整个函数体中最后执行的语句且它的返回值不属于表达式的一部分时，这个递归调用就是尾递归。
// 尾递归函数的特点是在回归过程中不用做任何操作，这个特性很重要，因为大多数现代的编译器会利用这种特点自动生成优化的代码。
Closure factorial
factorial = {
int number , BigInteger theFac -> number ==1?theFac : factorial.trampoline(number -1, number * theFac)
}.trampoline()
println "fac 5 ${factorial(5,1)}"
println "fac 5000 ${factorial(5000,1).bitCount()}"
}
static def pickEvent(n,Closure block) {
if (!block) return
println block.maximumNumberOfParameters
println block.parameterTypes
2.step(n, 2) {
def cu = block.curry(3)//传入的参数为两个，使用curry之后去掉了一个
cu("china: $it")
}
}
}
接口实现
package com.example
// 接口实现： Groovy 能把一个映射或者代码块转化为接口
public class test5 {
public static void main(String[] args) {
def mListener = [
do1: { println("$it") },
do2: { println(it + "dddddddd") },
//若仅仅实现部分方法，调用其他方法时会报空指针，此处不实现do3，报错如下
//Exception in thread "main" java.lang.UnsupportedOperationException,at com.sun.proxy.$Proxy0.do3(Unknown Source)
// do3: { java.lang.Object[] pars -> println("$pars") }
] as MListener
mListener.do1("do1")
mListener.do2("do2")
mListener.do3("do3", "333333")
//或者实现一个代码块，此时不论调用do1 ，或者do2 都会调用此代码块
// def mListener1 = {
// Object[] params -> println("$params")
// } as MListener
// mListener1.do1("do1")
// mListener1.do2("do2" , "aaaaaaa")
}
// lambda 表达式 接口
static interface MListener {
void do1(String str)
void do2(String str)
void do3(String str, String str2)
}
}
集合类
package com.example
//集合类
public class test6{
public static void main(String[] args) {
def lst = [1,2,3,4,5,6]
def sublst = lst[2..3] //新的一个ArrayList
println lst.dump()
println sublst.dump()
sublst[0] = -9999
println lst.dump()
println sublst.dump()
}
}
