一、环境搭建配置

1.安装Intellij IEDA开发工具 https://www.jetbrains.com/idea/download/
2.下载groovySDK开发工具 https://groovy.apache.org/download.html
3.配置环境变量 添加GROOVY_HOME变量 值：机器上的路径\apache-groovy-sdk-3.0.3\groovy-3.0.3 PATH中加入 %GROOVY_HOME%\bin
4.较验安装是否成功 控制台使用groovy -version，输出groovy的版本就说明成功

二、Hello World项目

helllo world.png

新建Groovy项目，选择下载的sdk版本Finish

//和java一样的写法 HelloWorld.groovy
//class HelloWorld {
//    public static void main(String[]args){
//        System.out.println("Hello World!")
//    }
//}

//class HelloWorld {
//    static void main(String[]args){
//        System.out.println("Hello World!")
//    }
//}
println("Hello World!")

三、变量

1、基本数据类型

注意：groovy中的基本数据类型都是以对象的形式存在的

//1.强类型 强类型没有初始值可以正常使用
int x = 1
double y = 3.14
char ch = 'a'
boolean flag = true
//class java.lang.Integer
//class java.lang.Double
//class java.lang.Character
//class java.lang.Boolean

//2.弱类型 弱类型没有初始值不可以正常使用
//java.lang.NullPointerException: Cannot get property 'class' on null object
def x =1 
def y = 3.14
def ch = 'a'
def flag = true
//class java.lang.Integer
//class java.math.BigDecimal
//class java.lang.String
//class java.lang.Boolean

//3.弱类型是可以自动转型的
x = 'hello'
y = "hello"
ch = '''hello'''
//class java.lang.String
//class java.lang.String
//class java.lang.String

println x.class
println y.class
println ch.class
println flag.class

2.String类型

//单引号  相当于java中的普通字符串
def name = 'lzr'
//def name = 'lzr \n hh'  //换行使用\n

//双引号
//def name2 = "lzr"
//双引号可以进行一些变量的操作赋值 这时候类型： org.codehaus.groovy.runtime.GStringImpl
//可以将表达式包含在字符串中，又称可扩展字符串
def name2 = "hello:${name}"

//三引号 可以用原始格式输出，比如换行回车等特殊字符不需要转义
//def name3 ='''lzr'''
//换行这样写
def name3 ='''lzr   
hh'''


println name
println name2
println name3

//正常都是String类型
println name.class
println name2.class
println name3.class


def string='hello'
//def string2='Hello'
def string2='el'
//groovy中常用的string相关的API
println string>string2 //hello 和Hello比较  true
println string[1..2]  //el
//减法
println string.minus(string2) //hlo
//逆序
println string.reverse() //olleh
//首字母大写
println string.capitalize() //Hello
//字符串中是否有数字字符
println string.isEmpty() //false

四、闭包

1.基本语法使用

闭包的定义：匿名内联函数，也称为一个闭包。 本质上，闭包是将函数内部和函数外部连接起来的桥梁。

//闭包的定义与使用
//无参数
def closure = {
    println "hello"
}
//调用
closure()
closure.call()

//默认的参数
def closure2 = {
    println "hello:${it}"
}
closure2.call("lzr")

//有参数
def closure3 = { String name, int age ->
    println "hello ${name} : age${age}"
}
closure3.call("lzr", 22)

//闭包的返回值
def closure4 = {
    println "hello"
    return "123"
}
def result = closure4.call()
println "result:" + result

2.内联函数说明

/**
 * 匿名内联函数，也称为一个闭包。
 * 基本类型相关的API
 */
int x = fab(5)
//upto 1*2*3*4*5
int fab(int number) {
    int result = 1
    1.upto(number, { num -> result *= num })
    return result
}
//源码如下：
public static void upto(Number self, Number to, @ClosureParams(FirstParam.class) Closure closure) {
    int self1 = self.intValue();    //1
    int to1 = to.intValue();       //number
    if (self1 > to1) {
        throw new GroovyRuntimeException("");
    } else {
        for(int i = self1; i <= to1; ++i) {
            closure.call(i);   //result = result *i
        }
    }
}
println x

//5*4*3*2*1
int fab2(int number) {
    int result = 1
    number.downto(1) {
        num -> result *= num
    }
    return result
}
//源码：
public static void downto(Number self, Number to, @ClosureParams(FirstParam.class) Closure closure) {
    int self1 = self.intValue();
    int to1 = to.intValue();
    if (self1 < to1) {
        throw new GroovyRuntimeException("");
    } else {
        for(int i = self1; i >= to1; --i) {
            closure.call(i);
        }
    }
}
println fab2(5)

//0+1+2+3+4
int sum(int number){
    int result = 0
    number.times {
        num->result += num
    }
    return result
}
//源码：
public static void times(Number self, @ClosureParams(value = SimpleType.class,options = {"int"}) Closure closure) {
    int i = 0;
    for(int size = self.intValue(); i < size; ++i) {
        closure.call(i);
        if (closure.getDirective() == 1) {
            break;
        }
    }
}
println sum(5)

/**
 * String 相关的API
 */

String str = "2and3is5"

//each遍历
str.each {
    //println it
    //对每一个字符2倍
    String s -> print s.multiply(2)//22aanndd33iiss55
}

//find查找符合条件的第一个字符
println str.find{
    String s->s.isNumber() //2
}

//findAll查找所有符合条件的
def list = str.findAll{
    String s ->s.isNumber() //[2, 3, 5]
}
println list.toListString()

//any 查找是否存在符合条件的字符
def result = str.any {
    String s ->s.isNumber()
}
println result //true

//every 查找是否所有字符都符合条件
def result2 = str.every {
    String s ->s.isNumber()
}
println result2 //false

//对每个一个字符操作后保存到一个集合里面
def list2 = str.collect {
    it.toUpperCase()
}
println list2.toListString() //[2, A, N, D, 3, I, S, 5]

3.关键变量

闭包的三个重要变量：this,owner,deleate
区别在于:this代表闭包定义处最近的对象(不包含闭包),owner代表闭包定义出最近的对象可以是闭包.delegate默认与owner一致.
delegate可以修改

文件名ClourseTest4.groovy
//1.在同一个闭包中，都是相同的对象
def scriptClouser = {
    println this//代表闭包定义处的类
    println owner//代表闭包定义处的类或者对象
    println delegate//代表任意对象，delegate默认为owner指向的对象
}
scriptClouser.call()
//com.lzr.study.closure.ClourseTest4@42530531
//com.lzr.study.closure.ClourseTest4@42530531
//com.lzr.study.closure.ClourseTest4@42530531

//2.在普通类或方法中定义闭包，三者是相同的
class Person {
    def static classClouser = {
        println "classClouser:" + this
        println "classClouser:" + owner
        println "classClouser:" + delegate
    }

    def static method() {
        def classClouser = {
            println "methodclassClouser:" + this
            println "methodclassClouser:" + owner
            println "methodclassClouser:" + delegate
        }
        classClouser.call()
    }
}
Person.classClouser.call()
Person.method()
//classClouser:class com.lzr.study.closure.Person

//3闭包内定义闭包    this内部对象    owner和delegate是外部对象
def nestClouser = {
    def innerClouser = {
        println "innerClouser:" + this
        println "innerClouser:" + owner
        println "innerClouser:" + delegate
    }
    innerClouser.call()
}
nestClouser.call()
//innerClouser:com.lzr.study.closure.ClourseTest4@5ba88be8
//innerClouser:com.lzr.study.closure.ClourseTest4$_run_closure1@1c33c17b  nestClouser 
//innerClouser:com.lzr.study.closure.ClourseTest4$_run_closure1@1c33c17b  nestClouser 

//4.修改默认的delegate对象
Person p=new Person();
def nestClouser = {
    def innerClouser = {
        println "innerClouser:" + this
        println "innerClouser:" + owner
        println "innerClouser:" + delegate
    }
    innerClouser.delegate=p;
    innerClouser.call()
}
nestClouser.call()
//innerClouser:com.lzr.study.closure.ClourseTest4@c94fd30
//innerClouser:com.lzr.study.closure.ClourseTest4$_run_closure1@77102b91
//innerClouser:com.lzr.study.closure.Person@45312be2

/**
 * 5.闭包的委托策略
 * Closure.OWNER_FIRST 优先owner
 * Closure.OWNER_ONLY  只允许owner
 * Closure.DELEGATE_FIRST 优先delegate
 * Closure.DELEGATE_ONLY  只允许delegate
 */
class Student{
    String name
    def pretty={"My name is ${name}"}
    String toString(){
        pretty.call()
    }
}
def student=new Student(name:'lzr')

class Teacher{
//    String name
}
//def teacher=new Teacher(name:'andy')

//只写这一句话不能改变委托对象,因为其默认的委托策略还是Closure.OWNER_FIRST(优先从owner中找),
//所以要设置为Closure.DELEGATE_FIRST(让他优先从delegate中找)
student.pretty.delegate=teacher
student.pretty.resolveStrategy=Closure.DELEGATE_FIRST
println student.toString() //My name is andy

//如果把Teacher的name去掉，优先delegate，找不到再去owner找
//当把stu的委托策略改成Closure.DELEGATE_ONLY时,会报错,因为此时找不到name
def teacher=new Teacher()
student.pretty.resolveStrategy=Closure.DELEGATE_FIRST
println student.toString() //My name is lzr