Classes, Fields & Properties

class Plant {
    String name
    int daysToHarvest
    double waterLitres = 0.5
}

def p = new Plant(name: 'basil', daysToHarvest: 30)
println "${p.name} ${p.daysToHarvest} ${p.waterLitres}"
println Plant.declaredFields.findAll { !it.synthetic }*.name.sort()
println Plant.declaredMethods*.name.findAll { it =~ /^[gs]et(?!MetaClass)/ }.sort()
assert java.lang.reflect.Modifier.isPublic(Plant.modifiers)   // classes are public by default
int days = 30
println days.class.name                  // a primitive used as an object is boxed
println p.daysToHarvest.getClass().name

basil 30 0.5
[daysToHarvest, name, waterLitres]
[getDaysToHarvest, getName, getWaterLitres, setDaysToHarvest, setName, setWaterLitres]
java.lang.Integer
java.lang.Integer

class Greenhouse {
    String name
    private List<String> log = []

    // inner class: sees the enclosing instance
    class Sensor {
        String id
        void report(double value) { log << "${id}=${value}" }
    }

    // static nested class: no enclosing instance
    static class Limits {
        static final double MAX_TEMP = 35.0
    }

    Sensor newSensor(String id) { new Sensor(id: id) }
}

def gh = new Greenhouse(name: 'north')
def s = gh.newSensor('t1')
s.report(21.5)
println gh.@log
println Greenhouse.Limits.MAX_TEMP

// anonymous inner class implementing an interface
def r = new Runnable() {
    void run() { println 'watering' }
}
r.run()
println r.class.isAnonymousClass()

// anonymous subclass of a class
def named = new Object() { String toString() { 'anon' } }
println named

[t1=21.5]
35.0
watering
true
anon

package demo

class Visibility {
    public String open = 'public field'
    protected String guarded = 'protected field'
    private String hidden = 'private field'
    String prop = 'property'
    @groovy.transform.PackageScope String pkg = 'package-private field'
    private String secret() { 'private method' }
}

def v = new Visibility()
// Groovy does not enforce private at run time
println v.hidden
println v.secret()
println v.guarded

println Visibility.declaredFields.findAll { !it.synthetic }.collect { f ->
    def m = f.modifiers
    "${f.name}: " + (java.lang.reflect.Modifier.isPublic(m) ? 'public' :
        java.lang.reflect.Modifier.isProtected(m) ? 'protected' :
        java.lang.reflect.Modifier.isPrivate(m) ? 'private' : 'package')
}.sort()

private field
private method
protected field
[guarded: protected, hidden: private, open: public, pkg: package, prop: private]

class Reading {
    String sensor            // property: private field + getter + setter
    final int id = 7         // final property: private final field + getter only
    public String label = 'L' // field, public: no accessors
    private double raw = 1.5  // field
    def noType                // property of type Object
}
def r = new Reading(sensor: 's1')
println r.sensor
r.sensor = 'Re-assigned'
println r.getSensor()
r.setSensor('via setter')
println r.sensor
println Reading.methods*.name.findAll { it ==~ /[gs]et[A-Z].*/ && !(it =~ /MetaClass|Property|getClass/) }.sort()
try { r.id = 9 } catch (ReadOnlyPropertyException e) { println e.message }
println r.properties.keySet().sort()
println r.properties.sensor
// direct field access with .@
println r.@sensor
println r.@raw

s1
Re-assigned
via setter
[getId, getNoType, getSensor, setNoType, setSensor]
Cannot set read-only property: id for class: Reading
[class, id, label, noType, raw, sensor]
via setter
via setter
1.5

class Config {
    static final String K = 'key' // static read-only property: getK() only
    static String s = 'shared'    // static property: getS() and setS()
    final String f = 'fixed'      // read-only property: getF() only
    public static final String C = 'const' // explicit modifier: a field, no accessors
}
println Config.methods*.name.findAll { it ==~ /[gs]et[A-Z].*/ && !(it =~ /MetaClass|Property|getClass/) }.sort()
println Config.K
Config.s = 'changed'
println Config.getS()
println new Config().getF()

[getF, getK, getS, setS]
key
changed
fixed

import groovy.transform.Field

@Field List<String> events = []

def record(String e) { events << e }
record 'opened'
record 'closed'
println events
println this.class.superclass.name
println this.class.declaredFields*.name.findAll { !it.startsWith('$') && !it.startsWith('_') }

[opened, closed]
groovy.lang.Script
[events]

class Plant {
    String name
    int daysToHarvest
}
class Zone {
    String id
    List<Plant> plants = []
}
def z = new Zone(id: 'A', plants: [new Plant(name: 'basil', daysToHarvest: 30), new Plant(name: 'mint', daysToHarvest: 45)])
// dynamic property names and subscript access
def prop = 'id'
println z."$prop"
println z['id']
println z.getProperty('id')
z.setProperty('id', 'B')
println z.id
// spread over the list of beans
println z.plants*.name
println z.plants.sum { it.daysToHarvest }
// a property is visible through the metaclass
println z.metaClass.properties*.name.sort()
println z.hasProperty('plants') != null
println z.hasProperty('nope')

A
A
A
B
[basil, mint]
75
[class, id, plants]
true
null

class Zone {
    String id
    int slots
    List<String> plants = []
    String toString() { "Zone($id, $slots, $plants)" }
}
// named-argument constructor: no-arg constructor then property setters
def z = new Zone(id: 'A', slots: 4, plants: ['basil'])
println z
// 'with' returns the closure result, 'tap' returns the receiver
def r1 = z.with { slots = 6; plants << 'mint'; 'ignored' }
println r1
def r2 = z.tap { slots = 8 }
println r2.is(z)
println z
// a plain Map can become an object with 'as' too
def z2 = [id: 'B', slots: 2] as Zone
println z2
// unknown name fails
try { new Zone(idd: 'x') } catch (MissingPropertyException e) { println e.message }

Zone(A, 4, [basil])
ignored
true
Zone(A, 8, [basil, mint])
Zone(B, 2, [])
No such property: idd for class: Zone
Possible solutions: id