Groovy基础语法总结

本文出自博客Vander丶CSDN博客，如需转载请标明出处，尊重原创谢谢
博客地址：http://www.voidcn.com/article/p-phbtzidn-bpt.html

写作目的

1.在Android Studio上不可避免的会涉及到Gradle的构建,而Gradle的构建正是基于Groovy之上.

2.相当于Groovy语法上的总结记录的博客,后续会继续更新.

3.更好的总结,有利于知识的巩固.

简介

Groovy是从Java衍生出来的,并且运行在Java虚拟机上的语言.其目标是不管作为脚本语言，还是编程语言，都可以简单、直接使用。

Groovy的一些基本语法

打印字符串到屏幕上

println 'Hello,World'
    println "Hello,World"

在Groovy中，字符串可以被单引号或者双引号包裹，都可以表达出字符串的含义。

但是他们有不同的用途，双引号字符串可以插入表达式，也就是可以插入占位符，这些占位符可以是变量也可以是方法，包含一个单独变量的占位符表达式可以只含有“$”前缀。

//def 是Groovy中声明变量的关键字
    def name = 'Andy'
    //在这里将占位符替换成name变量
    def getting = "Hello,${name}"
    //在这里是将占位符替换成 方法结果
    def name_size = "Your name is ${name.size()} characters long."

类和成员变量

在Groovy中创建一个类和在Java中创建一个类相似.

//请注意:无论是类,还是成员变量,包括方法都没有明确的访问修饰符.
//Groovy中的默认访问修饰符与Java不同.
//类和方法一样,是公有的,而类的成员确实私有的.
class MyGroovyClass {
    String greeting

    void setGreeting(String greeting) {
        this.greeting = greeting
    }

    String getGreeting() {
        return greeting
    }
}

使用一个类,包括使用一个类的成员变量:

//使用def关键字来创建新的变量，创建类也是
def instance =new MyGroovyClass()

instance.setGreeting('Hello World')

//当你试图直接调用一个成员变量时，实际上，你调用的是Getter方法，这里还可以用更简短的方式表达
instance.getGreeting()

instance.getGreeting

方法

Groovy中的方法就像使用变量一样，你无须为你的方法定义一个特定的返回类型，但如果为了方法能够更清新，也可以指定返回对象，在Groovy中，方法的最后一行通常默认返回，即使没有return关键字。

def square(def num){
        num * num
}

square 4

在Groovy的方法中，无论是返回类型，还是参数类型都没有明确的定义。这里使用了def关键字，而不是一个明确的类型，而且在没有使用return关键字的情况下，方法也隐晦的返回了一个值。

Closures

Closures是匿名代码块，可以接受参数和返回值。它们可以被视为变量，被当做参数传递给方法。

闭包，是一种数据类型，它代表了一段可执行的代码。其外形如下：

def aClosure = {//闭包是一段代码，所以需要用花括号括起来.. 
    String param1,int param2 -> //这个箭头很关键。箭头前面是参数定义，箭头后面是代码 
    println"this is code" //这是代码，最后一句是返回值， 
   //也可以使用return，和Groovy中普通函数一样 
}

简而言之，Closure的定义格式是：

def xxx = {paramters -> code}  //或者 
def xxx = {无参数，纯code}  //这种情况下是不需要->符号

Closure的调用和方法

aClosure.call("this is string",100)  或者  
aClosure("this is string",100) 

如果没有明确给closure指定一个参数，则Groovy会自动添加一个。这个参数通常被称为it，你可以在所有的closures中使用它，如果调用者没有指定任何参数，则it为空。

集合

在Gradle中使用Groovy时，有两个重要的集合类型：lists和maps

在Groovy中创建一个新的list非常简单，无须初始化：

List list = [1,2,3,4,5]

迭代List：

list.each(){
        println it
}

另一个集合类型Map，在Gradle中非常重要，它可在多个Gradle设置和方法中使用。

Map pizzaPrices = [margheria:10,prpperoni:12]

并且可以使用get方法来获取map中的特定项目:

pizzaPrices.get('pepperoni')
pizzaPrices['pepperoni']

而且Gradle也针对get方法做了简写

pizzaPrices.pepperoni

任务入门

定义任务

任务属于一个Project对象，并且每个任务都可以执行task接口。定义一个新任务的最简单方式是，执行将任务名称作为其参数的任务方法：

task hello

其创建了任务，但当你执行时，它不会做任何事情。为了创建一个有用的任务，你需要添加一些动作。初学者通常会犯的一个错误是像下面这样创建任务：

task  hello{
    println 'Hello,world!'
}

当你执行该任务时，会看到输出如下：

$  gradlew hello
Hello,world!
:hello

从输出来看，你可能觉得该任务运行了，但实际上，“Hello ， world！”在执行该任务之前就已经被打印出来了。

原因就是，在任意Gradle构建中，都有三个阶段：初始化阶段、配置阶段和执行阶段。而上述的任务则是设置了任务的配置。

如果你想在执行阶段给一个任务添加动作，则应该使用下面的表示法：

task hello << {
    println 'Hello,world'
}

唯一的不同就是closure之前的<<，其告知Gradle，代码在执行阶段执行，而不是在配置阶段。

Task在Gradle中有很多简写，在Gradle中定义任务的常用方式有以下几种：

task(hello) << { println 'Hello,world!' }

task('hello') << { println 'Hello,world!' }

tasks.create(name: 'hello') << { println 'Hello,world！' }

任务剖析

Task接口是所有任务的基础，其定义了一系列属性和方法。所有这些都是由一个叫做DefaultTask的类实现的。这是标准的任务实现方式，你创建的每一个新的任务，都是基于DefaultTask的。

每个任务都包含一个Action对象的集合。当一个任务被执行时，所有这些动作会以连续的顺序被执行。你可以使用doFirst()和doLast()方法来为一个任务添加动作。这些方法都是以一个closure作为参数，然后被包装到一个Action对象中的。

task hello {
    println 'Configuration'

    doLast {
     println 'Goodbye'
    }

    doFirst{
     println 'hello'
    }
}

当执行hello task时输出如下：

$ gradlew hello 
Configuration
:hello
hello
Goodbye

即使打印“Goodbye”的代码在“Hello”的代码之前定义，但当执行task时，他们仍会按正确的顺序执行。你甚至可以多次使用doFirst()和doLast()，如下所示：

task mindTheOrder{
    doFirst{
        println 'Not really first'
    }

    doFirst{
        println 'First!'
    }

    doLast{
        println 'Not really last'
    }

    doLast{
        println 'Last!'
    }
}

执行这个task的输出如下：

$ gradlew mindTheOrder
:mindTheOrder
First!
Not really first.
Not really last.
Last!

注意，doFirst()总是添加一个动作到task的最前面，而doLast()总是添加一个动作到最后面，这意味着，当使用这些方法的时候，顺序很重要。

当涉及给tasks排序时,可以使用mustRunAfter方法.

当使用mustRunAfter()时，你需要指定，如果两个任务都被执行，那么必须有一个任务始终先执行。

task task1 <<{
    println 'task1'
}

task task2 <<{
    println 'task2'
}

task2.mustRunAfter task1

同时运行task1和task2，不管你指定了什么样的顺序，task1总是在task2之前执行。

gradlew task2 task1
:task1
task1
:task2
task2

在这两个任务之间，mustRunAfter()方法不会添加任何依赖，因而我们可以只执行task2而不执行task1。如果你需要一个任务依赖于另一个，那么可使用dependsOn()方法。

dependsOn()的例子

task task1 << {
    println 'task1'
}

task task2 << {
    println 'task2'
}

task2.dependsOn task1

当你试图只执行task2而不执行task1时，结果如下：

$ gradlew task2
:task1
task1
:task2
task2

使用mustRunAfter(),当同时执行task1和task2时，task1总是在task2之前执行，两者也可以独立执行。使用dependsOn(),即使在未明确提及的情况下，task2的执行也总是会触发task1.这是一个重要的区别。

参考

1.Gradle for Android 中文版

2.深入理解Android（一）：Gradle详解
http://www.infoq.com/cn/articles/android-in-depth-gradle