groovy学习笔记

发布时间：2020-12-14 16:44:38 所属栏目：大数据来源：网络整理

导读：groovy学习 http://www.groovy-lang.org/documentation.html 安装： 1.1，安装gvmtools 地址：http://gvmtool.net 执行(for linux,mac,cygwin)： $ curl -s get.gvmtool.net | bash $ source "$HOME/.gvm/bin/gvm-init.sh" $ gvm install groovy $ groovy -v

groovy学习

http://www.groovy-lang.org/documentation.html

安装：

1.1，安装gvmtools

地址：http://gvmtool.net
执行(for linux,mac,cygwin)：

$ curl -s get.gvmtool.net | bash
$ source "$HOME/.gvm/bin/gvm-init.sh"
$ gvm install groovy
$ groovy -version

1.2 使用二进制包

1，下载

2，设置 GROOVY_HOME

3，将 GROOVY_HOME/bin 添加到 PATH中

4，设置 JAVA_HOME

5，验证 groovy -version

使用

命令行：

groovysh

armytekiMacBook-Air:~ army$ groovysh
Groovy Shell (2.4.4,JVM: 1.7.0_45)
Type ':help' or ':h' for help.
-------------------------------------------------------------------------------
groovy:000> :h
For information about Groovy,visit:
http://groovy-lang.org 

groovy:000> class Server {String name}
===> true
groovy:000> server = new Server(name:'tt')
===> Server@3fbbaaad
groovy:000> println server.getName()
tt

界面：

groovyConsole

脚本：

groovy SomeScript

shell 脚本方式：

#!/usr/bin/env groovy

println 'Hello'
map=[:]
map."a"="1"
println map

class Person{
    String name
    Person(name){
        this.name = name
    }
}
def person = new Person(null);

println person?.name

与Java比较

http://www.groovy-lang.org/differences.html

1,groovy默认引入了下列包，不需要显式import:

java.io.*
java.lang.*
java.math.BigDecimal
java.math.BigInteger
java.net.*
java.util.*
groovy.lang.*
groovy.util.*
2,方法重载

Groovy的方法在运行时根据实际传入的参数类型调用，在Java中方法在编译时基于声明的类型确定。

int method(String arg) {
    return 1;
}
int method(Object arg) {
    return 2;
}
Object o = "Object";
int result = method(o);

In Java,you would have:

assertEquals(2,result);

Whereas in Groovy:

assertEquals(1,result);

3，数据结构

在Groovy中，{}是个保留字，所以用 [] 来表示数组（ Java中使用{},int[] array={1,2,3} ）：

def list = [1,4,6,9]

// equivalent to add()
list << 5

// call contains()
assert 4 in list

// subscript notation
assert list[1] == 4

map的key如果是字符串，不需要加引号，如果key是个变量或者对象,则like [(variableStateAcronym): stateName]

def map = [CA: 'California',MI: 'Michigan']

// add a new key value pair
map << [WA: 'Washington']

// subscript notation
assert map['CA'] == 'California'

// property notation
assert map.WA == 'Washington'

4,String类型

Groovy支持”,”“两种格式的字符串类型，”” 支持 “${}” 插入表达式（称为 GString）:

assert 'c'.getClass()==String
assert "c".getClass()==String
assert "c${1}".getClass() in GString

对char类型，单个String字符可以赋给char类型，多个字符通过as char/asType(char) 转为char类型会取第一个字符。

// for single char strings,both are the same
assert ((char) "c").class==Character
assert ("c" as char).class==Character

// for multi char strings they are not
try {
  ((char) 'cx') == 'c'
  assert false: 'will fail - not castable'
} catch(GroovyCastException e) {
}
assert ('cx' as char) == 'c'
assert 'cx'.asType(char) == 'c'

对String换行的情况，可以用 +,,"""

throw new PluginException("Failed to execute command list-applications:" +
" The group with name " +
parameterMap.groupname[0] +
" is not compatible group of type " +
SERVER_TYPE_NAME)

throw new PluginException("Failed to execute command list-applications: 
The group with name ${parameterMap.groupname[0]} 
is not compatible group of type ${SERVER_TYPE_NAME}")

throw new PluginException("""Failed to execute command list-applications:
The group with name ${parameterMap.groupname[0]}
is not compatible group of type ${SERVER_TYPE_NAME)}""")

正则表达式，用 ~pattern 来表示，=~（创建一个Matcher）,==~ (返回boolean，字符串是否匹配pattern)

def pattern = ~/fo*/   

// matches() strings against patterns
assert 'foo' =~ pattern


assert 'foo' ==~ pattern

5,基本类型和==

Groovy使用Object概念。所有的基本类型也都封装成对象。
在java中，==表示基本类型相等，对象类型相同。
在Groovy中，==表示 a.compareTo(b)==0 or a.equals(b). 相同的比较，使用a.is(b)

6，Groovy 中 ; 可选

7，Groovy 中 return 可选

String toString() { return "a server" }
String toString() { "a server" }

8，Groovy 中 def 表示变量类型为 object

def foo(n) {
    "Roshan"
}
assert foo(1) == "Roshan"

9,Groovy 类的变量和方法默认为 public

Groovy 默认类和方法都是是 public，如果不是public，可以增加注解 @PackageScope
```
class Person {
    String name
}
```
Groovy编译器生成了一个私有的属性，和对应的 setter、getter方法。

10,Groovy 中可以省略 ()

println "Hello"   ___     println("Hello") 
method a,b          /     method(a,b)

11，with() 用于对同一个bean的重复操作

server.name = xxx                       server.with {
server.status = xxx             ___      name = xxx ...
...                                /      start()
server.start()                          }

12，switch

def x = 1.23
def result = ""
switch (x) {
    case "foo": result = "found foo"
    // lets fall through
    case "bar": result += "bar"
    case [4,5,'inList']:
        result = "list"
        break
    case 12..30:
        result = "range"
        break
    case Integer:
        result = "integer"
        break
    case Number:
        result = "number"
        break
    case { it > 3 }:
        result = "number > 3"
        break
    default: result = "default"
}
assert result == "number"

13 import 别名

import java.util.List as juList

import static pkg.SomeClass.foo
foo()

14 Groovy的布尔值

在Groovy中，所有的对象都可以强制转化成布尔值，null,void,0，空都等于false，否则是true。甚至，可以在类中增加 asBoolean（） 来定制Groovy的Turth。
```
if (name != null && name.length > 0) {}
if (name) {}
```
15 Groovy的安全性
```
println order?.customer?.address
```
在对象后面增加?,可以避免抛出 NonePointerException,并且返回 null

16 异常捕获

try {
    // ...
} catch (any) {
    // something bad happens
}

程序结构

1，Groovy 脚本会编译成类，其中的执行代码放到run函数中。脚本的名字会编译成类名，Main.groovy 变成 Main.class

class Main {                                    
    static void main(String... args) {          
        println 'Groovy world!'                 
    }
}

等于

import org.codehaus.groovy.runtime.InvokerHelper
    class Main extends Script {                     
        def run() {
            println 'Groovy world!'
        }
        static void main(String[] args) {           
            InvokerHelper.runScript(Main,args)     
        }
    }

2，闭包 { [closureParameters -> ] statements }

Closure callback = { println "done" }
callback()
callback.call()

def closureWithTwoArgs = { a,b -> a+b }
assert closureWithTwoArgs(1,2) == 3

def closureWithTwoArgAndDefaultValue = { int a,int b=2 -> a+b }
assert closureWithTwoArgAndDefaultValue(1) == 3
assert closureWithTwoArgAndDefaultValue(1,4) == 5

当闭包没有使用->显式定义参数,则默认用 it 表示参数。

def greeting = { "Hello,$it!" }
assert greeting('Patrick') == 'Hello,Patrick!'

入参是变长的参数列表时，可以使用 … args

def concat1 = { String... args -> args.join('') }           
assert concat1('abc','def') == 'abcdef'

3,代理

class Enclosing {
        void run() {
            def whatIsThisObject = { getThisObject() }          
            assert whatIsThisObject() == this                   
            def whatIsThis = { this }                           
            assert whatIsThis() == this                         
        }
    }
    class Enclosing {
        void run() {
            def whatIsOwnerMethod = { getOwner() }               
            assert whatIsOwnerMethod() == this                   
            def whatIsOwner = { owner }                          
            assert whatIsOwner() == this                         
        }
    }

    class Person { String name }
    class Thing { String name }
    def p = new Person(name: 'Norman')
    def t = new Thing(name: 'Teapot')

    def upperCasedName = { delegate.name.toUpperCase() }
    upperCasedName.delegate = p
    assert upperCasedName() == 'NORMAN'
    upperCasedName.delegate = t
    assert upperCasedName() == 'TEAPOT'

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!