// a standalone single line comment

println "hello" // a comment till the end of the line

/* a standalone multiline comment

   spanning two lines */

println "hello" /* a multiline comment starting

                   at the end of a statement */

println 1 /* one */ + 2 /* two */

/**

 * A Class description

 */

class Person {

    /** the name of the person */

    String name


    /**

     * Creates a greeting method for a certain person.

     *

     * @param otherPerson the person to greet

     * @return ag reeting message

     */

    String greet(String otherPerson) {

       "Hello ${otherPerson}"

    }

}

#!/usr/bin/env groovy

println "Hello from the shebang line"

def name

def item3

def with_underscore

def $dollarStart

def 3tier

def a+b

def a#b

foo.as

foo.assert

foo.break

foo.case

foo.catch

def map = [:]


map."an identifier with a space and double quotes" = "ALLOWED"

map.'with-dash-signs-and-single-quotes' = "ALLOWED"


assert map."an identifier with a space and double quotes" == "ALLOWED"

assert map.'with-dash-signs-and-single-quotes' == "ALLOWED"

map.'single quote'

map."double quote"

map.'''triple single quote'''

map."""triple double quote"""

map./slashy string/

map.$/dollar slashy string/$

def firstname = "Homer"

map."Simson-${firstname}" = "Homer Simson"


assert map.'Simson-Homer' == "Homer Simson"

def firstname = "Homer"

map."Simson-${firstname}" = "Homer Simson"


assert map.'Simson-Homer' == "Homer Simson"

assert 'ab' == 'a' + 'b'

'a single quoted string'

def aMultilineString = '''line one

line two

line three'''

def startingAndEndingWithANewline = '''

line one

line two

line three

'''

def strippedFirstNewline = '''\

line one

line two

line three

'''


assert !strippedFirstNewline.startsWith('\n')

"a double quoted string"

def name = 'Groovy'

def template = """

    Dear Mr ${name},


    You're the winner of the lottery!


    Yours sincerly,


    Dave

"""


assert template.toString().contains('Groovy')

def fooPattern = /.*foo.*/

assert fooPattern == '.*foo.*'

def escapeSlash = /The character \/ is a forward slash/

assert escapeSlash == 'The character / is a forward slash'

def multilineSlashy = /one

    two

    three/


assert multilineSlashy.contains('\n')

def color = 'blue'

def interpolatedSlashy = /a ${color} car/


assert interpolatedSlashy == 'a blue car'

assert '' == //

def name = "Guillaume"

def date = "April, 1st"


def dollarSlashy = $/

    Hello $name,

    today we're ${date}.


    $ dollar sign

    $$ escaped dollar sign

    \ backslash

    / forward slash

    $/ escaped forward slash

    $/$ escaped dollar slashy string delimiter

/$


assert [

    'Guillaume',

    'April, 1st',

    '$ dollar sign',

    '$ escaped dollar sign',

    '\\ backslash',

    '/ forward slash',

        '$/ escaped forward slash',

        '/$ escaped dollar slashy string delimiter'


        ].each { dollarSlashy.contains(it) }

char c1 = 'A' (1)
assert c1 instanceof Character

def c2 = 'B' as char (2)
assert c2 instanceof Character

def c3 = (char)'C' (3)
assert c3 instanceof Character

// 基本类型

byte  b = 1

char  c = 2

short s = 3

int   i = 4

long  l = 5


// 无限精度

BigInteger bi =  6

def a = 1

assert a instanceof Integer


// Integer.MAX_VALUE

def b = 2147483647

assert b instanceof Integer


// Integer.MAX_VALUE + 1

def c = 2147483648

assert c instanceof Long


// Long.MAX_VALUE

def d = 9223372036854775807

assert d instanceof Long


// Long.MAX_VALUE + 1

def e = 9223372036854775808

assert e instanceof BigInteger

def na = -1

assert na instanceof Integer


// Integer.MIN_VALUE

def nb = -2147483648

assert nb instanceof Integer


// Integer.MIN_VALUE - 1

def nc = -2147483649

assert nc instanceof Long


// Long.MIN_VALUE

def nd = -9223372036854775808

assert nd instanceof Long


// Long.MIN_VALUE - 1

def ne = -9223372036854775809

assert ne instanceof BigInteger

// primitive types

float  f = 1.234

double d = 2.345


// infinite precision

BigDecimal bd =  3.456

assert 1e3  ==  1_000.0

assert 2E4  == 20_000.0

assert 3e+1 ==     30.0

assert 4E-2 ==      0.04

assert 5e-1 ==      0.5

long creditCardNumber = 1234_5678_9012_3456L

long socialSecurityNumbers = 999_99_9999L

double monetaryAmount = 12_345_132.12

long hexBytes = 0xFF_EC_DE_5E

long hexWords = 0xFFEC_DE5E

long maxLong = 0x7fff_ffff_ffff_ffffL

long alsoMaxLong = 9_223_372_036_854_775_807L

long bytes = 0b11010010_01101001_10010100_10010010

assert 42I == new Integer('42')

assert 42i == new Integer('42') // lowercase i more readable

assert 123L == new Long("123") // uppercase L more readable

assert 2147483648 == new Long('2147483648') // Long type used, value too large for an Integer

assert 456G == new BigInteger('456')

assert 456g == new BigInteger('456')

assert 123.45 == new BigDecimal('123.45') // default BigDecimal type used

assert 1.200065D == new Double('1.200065')

assert 1.234F == new Float('1.234')

assert 1.23E23D == new Double('1.23E23')

assert 0b1111L.class == Long // binary

assert 0xFFi.class == Integer // hexadecimal

assert 034G.class == BigInteger // octal

assert  1  + 2 == 3

assert  4  - 3 == 1

assert  3  * 5 == 15

assert  3  / 2 == 1.5

assert 10  % 3 == 1

assert  2 ** 3 == 8

assert +3 == 3

assert -4 == 0 - 4


assert -(-1) == 1  (1)

def a = 2

def b = a++ * 3             (1)


assert a == 3 && b == 6


def c = 3

def d = c-- * 2             (2)


assert c == 2 && d == 6


def e = 1

def f = ++e + 3             (3)


assert e == 2 && f == 5


def g = 4

def h = --g + 1             (4)


assert g == 3 && h == 4

def a = 4

a += 3


assert a == 7


def b = 5

b -= 3


assert b == 2


def c = 5

c *= 3


assert c == 15


def d = 10

d /= 2


assert d == 5


def e = 10

e %= 3


assert e == 1

assert !false && true    (1)

assert false || true && true    (1)

called = false


boolean somethingTrueOrFalse(boolean b) {  (1)

    called = true

    return b

}


assert true || somethingTrueOrFalse(false)

assert !called                              (2)


assert false || somethingTrueOrFalse(true)

assert called                               (3)

assert (!true)    == false                      (1)

assert (!'foo')   == false                      (2)

assert (!'')      == true                       (3)

if (string!=null && string.length()>0) {

    result = 'Found'

} else {

    result = 'Not found'

}

result = (string!=null && string.length()>0)?'Found':'Not found'

result = string?'Found':'Not found'

displayName = user.name ? user.name : 'Anonymous'   (1)

displayName = user.name ?: 'Anonymous'              (2)

def person = Person.find { it.id == 123 }           (1)

def name = person?.name                             (2)

assert name == null                                 (3)

class User {

    public final String name                               (1)

    User(String name) { this.name = name}

    String getName() { "Name: $name" }                     (2)

}

def user = new User('Bob')

assert user.name == 'Name: Bob'                            (3)

assert user.@name == 'Bob'                                 (1)

def str = 'example of method reference'            (1)

def fun = str.&toUpperCase                         (2)

def upper = fun()                                  (3)

assert upper == str.toUpperCase()                  (4)

def transform(List elements, Closure action) {                                      (1)

    def result = []

    elements.each {

        result << action(it)

    }

    result

}

String describe(Person p) {                                                         (2)

    "$p.name is $p.age"

}

def action = this.&describe                                                         (3)

def list = [new Person(name:'Bob', age:42), new Person(name:'Julia',age:35)]        (4)

assert transform(list, action) == ['Bob is 42', 'Julia is 35']                      (5)

def doSomething(String str) { str.toUpperCase() }                                   (1)

def doSomething(Integer x) { 2*x }                                                  (2)

def reference = this.&doSomething                                                   (3)

assert reference('foo') == 'FOO'                                                    (4)

assert reference(123)   == 246                                                      (5)

def p = ~/foo/

assert p instanceof Pattern

p = ~'foo'                                                                              (1)

p = ~'foo'                                                                              (2)

p = ~$/dollar/slashy $ string/$                                                         (3)

p = ~"${pattern}"                                                                       (4)

def text = "some text to match"

def m = text =~ /match/                                                                 (1)

assert m instanceof Matcher                                                             (2)

if (!m) {                                                                               (3)

    throw new RuntimeException("Oops, text not found!")

}

m = text ==~ /match/                                                                    (1)

assert m instanceof Boolean                                                             (2)

if (m) {                                                                                (3)

    throw new RuntimeException("Should not reach that point!")

}

class Car {

    String make

    String model

}

def cars = [

       new Car(make:'Peugeot', model:'508'),

       new Car(make:'Renault', model:'Clio')]                                    (1)

def makes = cars*.make                                                           (2)

assert makes == ['Peugeot', 'Renault']                                           (3)

cars = [

   new Car(make:'Peugeot', model:'508'),

   null,                                                                         (1)

   new Car(make:'Renault', model:'Clio')]

assert cars*.make == ['Peugeot', null, 'Renault']                                (2)

assert null*.make == null                                                        (3)

class Component {

    Long id

    String name

}

class CompositeObject implements Iterable<Component> {

    def components = [

        new Component(id:1, name: 'Foo'),

        new Component(id:2, name:'Bar')]


    @Override

    Iterator<Component> iterator() {

        components.iterator()

    }

}

def composite = new CompositeObject()

assert composite*.id == [1,2]

assert composite*.name == ['Foo','Bar']

def range = 0..5                                    (1)

assert (0..5).collect() == [0, 1, 2, 3, 4, 5]       (2)

assert (0..<5).collect() == [0, 1, 2, 3, 4]         (3)

assert (0..5) instanceof List                       (4)

assert (0..5).size() == 6                           (5)

assert ('a'..'d').collect() == ['a','b','c','d']

assert (1 <=> 1) == 0

assert (1 <=> 2) == -1

assert (2 <=> 1) == 1

assert ('a' <=> 'z') == -1

def list = [0,1,2,3,4]

assert list[2] == 2                         (1)

list[2] = 4                                 (2)

assert list[0..2] == [0,1,4]                (3)

list[0..2] = [6,6,6]                        (4)

assert list == [6,6,6,3,4]                  (5)

class User {

    Long id

    String name

    def getAt(int i) {                                                  (1)

        switch (i) {

            case 0: return id

            case 1: return name

        }

        throw new IllegalArgumentException("No such element $i")

    }

    void putAt(int i, def value) {                                      (2)

        switch (i) {

            case 0: id = value; return

            case 1: name = value; return

        }

        throw new IllegalArgumentException("No such element $i")

    }

}

def user = new User(id: 1, name: 'Alex')                                (3)

assert user[0] == 1                                                     (4)

assert user[1] == 'Alex'                                                (5)

user[1] = 'Bob'                                                         (6)

assert user.name == 'Bob'                                               (7)

def list = ['Grace','Rob','Emmy']

assert ('Emmy' in list)                     (1)

def list1 = ['Groovy 1.8','Groovy 2.0','Groovy 2.3']        (1)

def list2 = ['Groovy 1.8','Groovy 2.0','Groovy 2.3']        (2)

assert list1 == list2                                       (3)

assert !list1.is(list2)                                     (4)

Integer x = 123

String s = (String) x                                   (1)

Integer x = 123

String s = x as String                                  (1)

class Identifiable {

    String name

}

class User {

    Long id

    String name

    def asType(Class target) {                                              (1)

        if (target==Identifiable) {

            return new Identifiable(name: name)

        }

        throw new ClassCastException("User cannot be coerced into $target")

    }

}

def u = new User(name: 'Xavier')                                            (2)

def p = u as Identifiable                                                   (3)

assert p instanceof Identifiable                                            (4)

assert !(p instanceof User)                                                 (5)

List<String> strings = new LinkedList<>()

class MyCallable {

    int call(int x) {           (1)

        2*x

    }

}


def mc = new MyCallable()

assert mc.call(2) == 4          (2)

assert mc(2) == 4               (3)

new Date()

import java.lang.*

import java.util.*

import java.io.*

import java.net.*

import groovy.lang.*

import groovy.util.*

import java.math.BigInteger

import java.math.BigDecimal

//imports the class MarkupBuilder

import groovy.xml.MarkupBuilder


//uses the imported class to create an object

def xml = new MarkupBuilder( )


assert xml != null

import groovy.xml.MarkupBuilder

import groovy.xml.StreamingMarkupBuilder


def markupBuilder = new MarkupBuilder( )


assert markupBuilder != null


assert new StreamingMarkupBuilder() != null

import groovy.xml.*


def markupBuilder = new MarkupBuilder( )


assert markupBuilder != null


assert new StreamingMarkupBuilder() != null

import static Boolean.FALSE


assert !FALSE //use directly, without Boolean prefix!

import static Calendar.getInstance as now


assert now().class == Calendar.getInstance().class

import static java.lang.Math.*


assert sin(0) == 0.0

assert cos(0) == 1.0

package thirdpartylib


public class MultiplyTwo {

    def static multiply(def value) {

        return value * 3 //intentionally wrong.

    }

}

def result = new MultiplyTwo().multiply(2)

import thirdpartylib.MultiplyTwo as OrigMultiplyTwo

class MultiplyTwo extends OrigMultiplyTwo {

    def multiply(def value)

    {

        return value * 2 //corrected here

    }

}

// nothing changes below here

def multiplylib = new MultiplyTwo()


//assert passes as well

assert 4 == new MultiplyTwo().multiply(2)

trait Introspector {

    def whoAmI() { this }

}

class Foo implements Introspector {}

def foo = new Foo()

foo.whoAmI()

assert foo.whoAmI().is(foo)

interface Named {                                       (1)

    String name()

}

trait Greetable implements Named {                      (2)

    String greeting() { "Hello, ${name()}!" }

}

class Person implements Greetable {                     (3)

    String name() { 'Bob' }                             (4)

}


def p = new Person()

assert p.greeting() == 'Hello, Bob!'                    (5)

assert p instanceof Named                               (6)

assert p instanceof Greetable                           (7)

trait Named {

    String name                             (1)

}

class Person implements Named {}            (2)

def p = new Person(name: 'Bob')             (3)

assert p.name == 'Bob'                      (4)

assert p.getName() == 'Bob'                 (5)

trait FlyingAbility {                           (1)

        String fly() { "I'm flying!" }          (2)

}

trait SpeakingAbility {

    String speak() { "I'm speaking!" }

}

class Duck implements FlyingAbility, SpeakingAbility {} (1)


def d = new Duck()                                      (2)

assert d.fly() == "I'm flying!"                         (3)

assert d.speak() == "I'm speaking!"                     (4)

class Duck implements FlyingAbility, SpeakingAbility {

    String quack() { "Quack!" }                         (1)

    String speak() { quack() }                          (2)

}


def d = new Duck()

assert d.fly() == "I'm flying!"                         (3)

assert d.quack() == "Quack!"                            (4)

assert d.speak() == "Quack!"                            (5)

interface MessageHandler {

    void on(String message, Map payload)

}

trait DefaultHandler implements MessageHandler {

    void on(String message, Map payload) {

        println "Received $message with payload $payload"

    }

}

class SimpleHandler implements DefaultHandler {}

class SimpleHandlerWithLogging implements DefaultHandler {

    void on(String message, Map payload) {                                  (1)

        println "Seeing $message with payload $payload"                     (2)

        DefaultHandler.super.on(message, payload)                           (3)

    }

}

trait LoggingHandler implements MessageHandler {                            (1)

    void on(String message, Map payload) {

        println "Seeing $message with payload $payload"                     (2)

        super.on(message, payload)                                          (3)

    }

}

class HandlerWithLogger implements DefaultHandler, LoggingHandler {}

def loggingHandler = new HandlerWithLogger()

loggingHandler.on('test logging', [:])

Seeing test logging with payload [:]

Received test logging with payload [:]

trait SayHandler implements MessageHandler {

    void on(String message, Map payload) {

        if (message.startsWith("say")) {                                    (1)

            println "I say ${message - 'say'}!"

        } else {

            super.on(message, payload)                                      (2)

        }

    }

}

class Handler implements DefaultHandler, SayHandler, LoggingHandler {}

def h = new Handler()

h.on('foo', [:])

h.on('sayHello', [:])

Seeing foo with payload [:]

Received foo with payload [:]

Seeing sayHello with payload [:]

I say Hello!

class AlternateHandler implements DefaultHandler, LoggingHandler, SayHandler {}

h = new AlternateHandler()

h.on('foo', [:])

h.on('sayHello', [:])

Seeing foo with payload [:]

Received foo with payload [:]

I say Hello!

class A { String methodFromA() { 'A' } }        (1)

class B { String methodFromB() { 'B' } }        (2)

A.metaClass.mixin B                             (3)

def o = new A()

assert o.methodFromA() == 'A'                   (4)

assert o.methodFromB() == 'B'                   (5)

assert o instanceof A                           (6)

assert !(o instanceof B)                        (7)

trait TestHelper {

    public static boolean CALLED = false        (1)

    static void init() {                        (2)

        CALLED = true                           (3)

    }

}

class Foo implements TestHelper {}

Foo.init()                                      (4)

assert Foo.TestHelper__CALLED                   (5)

Foo.CALLED = true

class Bar implements TestHelper {}              (1)

class Baz implements TestHelper {}              (2)

Bar.init()                                      (3)

assert Bar.TestHelper__CALLED                   (4)

assert !Baz.TestHelper__CALLED                  (5)

trait IntCouple {

    int x = 1

    int y = 2

    int sum() { x+y }

}

class BaseElem implements IntCouple {

    int f() { sum() }

}

def base = new BaseElem()

assert base.f() == 3

class Elem implements IntCouple {

    int x = 3                                       (1)

    int y = 4                                       (2)

    int f() { sum() }                               (3)

}

def elem = new Elem()

assert elem.f() == 3

trait IntCouple {

    int x = 1

    int y = 2

    int sum() { getX()+getY() }

}


class Elem implements IntCouple {

    int x = 3

    int y = 4

    int f() { sum() }

}

def elem = new Elem()

assert elem.f() == 7