关闭

Groovy基础语法总结

标签: groovyandroidjavaandroid studio脚本语言
460人阅读 评论(2) 收藏 举报
分类:

本文出自博客Vander丶CSDN博客,如需转载请标明出处,尊重原创谢谢
博客地址:http://blog.csdn.net/l540675759/article/details/69228418


写作目的

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
3
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:42803次
    • 积分:1021
    • 等级:
    • 排名:千里之外
    • 原创:36篇
    • 转载:0篇
    • 译文:3篇
    • 评论:117条
    博客专栏