Methods, Constructors & Parameters

// Methods: return type, def, implicit return, static, visibility
class Calc {
    int twice(int x) { x * 2 }                   // last expression is the result
    def describe(x) { "value: $x" }              // untyped parameter and result
    static String unit() { 'celsius' }
    private int secret() { 42 }
    void noResult() { 1 + 1 }                    // void discards the value
    int explicit(int x) { return x + 1 }
}
def c = new Calc()
println c.twice(21)
println c.describe([1, 2])
println Calc.unit()
println c.noResult()
println c.explicit(1)
// parentheses are optional for calls with arguments
def r = c.twice 4
println r
// private is not enforced at run time for calls made from Groovy
println c.secret()

42
value: [1, 2]
celsius
null
2
8
42

class Sprinkler {
    String zone
    int litres

    Sprinkler() { zone = 'none'; litres = 0 }
    Sprinkler(String zone) { this(zone, 10) }          // constructor chaining
    Sprinkler(String zone, int litres) { this.zone = zone; this.litres = litres }

    String toString() { "Sprinkler($zone, $litres)" }
}

def a = new Sprinkler()
def b = new Sprinkler('north')
Sprinkler c = ['south', 20]          // list coercion calls the constructor
def d = ['east', 5] as Sprinkler     // explicit coercion
def e = new Sprinkler(zone: 'west', litres: 7)   // no-arg constructor plus setters
println([a, b, c, d, e])

[Sprinkler(none, 0), Sprinkler(north, 10), Sprinkler(south, 20), Sprinkler(east, 5), Sprinkler(west, 7)]

// Named parameters in a method: collected into a Map as the first parameter
def water(Map opts, int litres) {
    "${opts.zone ?: 'all'} gets $litres l at ${opts.at ?: 'now'}"
}
println water(zone: 'north', at: '06:00', 30)
try { water(20) } catch (MissingMethodException e) { println 'no Map given: ' + e.message.readLines()[0] }
println water([:], 20)
println water(30, zone: 'south')       // named arguments may appear anywhere in the call

north gets 30 l at 06:00
no Map given: No signature of method: water for class: blk4 is applicable for argument types: (Integer) values: [20]
all gets 20 l at now
south gets 30 l at now

// Default arguments
String report(String zone, int days = 7, String unit = 'celsius') { "$zone/$days/$unit" }
println report('a')
println report('a', 14)
println report('a', 14, 'kelvin')
println this.class.declaredMethods*.name.findAll { it == 'report' }.size()

// Varargs
int total(int... values) { values.sum(0) }
println total()
println total(1)
println total(1, 2, 3)
println total([4, 5] as int[])
String join(String sep, Object... parts) { parts.join(sep) }
println join('-', 'a', 1, 2.5)
println join('-')

a/7/celsius
a/14/celsius
a/14/kelvin
3
0
1
6
9
a-1-2.5

// Method selection: the runtime types of the arguments decide
String pick(Object o)  { 'Object' }
String pick(String s)  { 'String' }
String pick(Integer i) { 'Integer' }
String pick(Number n)  { 'Number' }
String pick(int i)     { 'int' }
String pick(CharSequence cs) { 'CharSequence' }

Object o = 'text'
println pick(o)                  // runtime type String, not declared type Object
println pick(1)
println pick(1L)
println pick(1.5)
println pick("g${1}")            // GString: no GString overload, so CharSequence
println pick(null)               // resolved by distance to Object
println pick(new StringBuilder('x'))

String
Integer
Number
Number
CharSequence
Object
CharSequence

// Multi-methods versus Java: dispatch on runtime type
class Animal { }
class Dog extends Animal { }
String sound(Animal a) { 'generic' }
String sound(Dog d)    { 'woof' }
Animal a = new Dog()
println sound(a)                                   // Groovy: woof; Java would print generic
println sound(a as Animal)

// Ambiguity
interface A {}
interface B {}
class Both implements A, B {}
String amb(A a) { 'A' }
String amb(B b) { 'B' }
try { amb(new Both()) } catch (e) { println e.class.simpleName }

woof
generic
GroovyRuntimeException

// Exception declaration is optional and unchecked
class Loader {
    String load(String path) throws IOException {
        if (!path) throw new IOException('empty path')
        return "loaded $path"
    }
    String loadQuiet(String path) {                 // no throws clause needed
        throw new FileNotFoundException(path)
    }
}
def l = new Loader()
println l.load('a.cfg')
try { l.load('') } catch (IOException e) { println "caught ${e.message}" }
// checked exception escapes without being declared or caught
try { l.loadQuiet('missing.cfg') } catch (e) { println e.class.simpleName }

loaded a.cfg
caught empty path
FileNotFoundException