We can examine classes in Groovy to find out information in the form of strings.

Examining Classes

To find out a class's name and superclasses:

class A{}
assert A.name == 'A'
assert new A().class.name == 'A'
assert A.class.name == 'A' //'class' is optionally used here

class B extends A{}
assert B.name == 'B'

class C extends B{}
def hierarchy= []
def s = C
while(s != null){ hierarchy << s.name; s= s.superclass }
assert hierarchy == [ 'C', 'B', 'A', 'java.lang.Object' ]

To examine the interfaces:

interface A1{}
interface A2{}
class A implements A1, A2{}
def interfacesA = [] as Set  //use a set because interfaces are unordered
A.interfaces.each{ interfacesA << it.name }
assert interfacesA == [ 'A1', 'A2', 'groovy.lang.GroovyObject' ] as Set

interface B1{}
class B extends A implements B1{}
def interfacesB = [] as Set
B.interfaces.each{ interfacesB << it.name }
assert interfacesB == [ 'B1' ] as Set
  //only immediately implemented interfaces are reported

We can check if a class is a class or an interface:

assert Observer.isInterface()
assert ! Observable.isInterface()

We can examine public fields and their types:

class A{
  def adyn //if no modifier, field is private
  String astr
  public apdyn
  public String apstr
  protected aqdyn
}
interface B1{}
interface B2{}
class B extends A implements B1, B2{
  def bdyn
  int bint
  public bpdyn
  public int bpint
  protected bqdyn
}
def dets = [] as Set
B.fields.each{ //public fields only
  dets << [ it.name, it.type.name ] //name of field and name of type
}
assert dets == [
  [ 'apstr', 'java.lang.String' ],
  [ 'apdyn', 'java.lang.Object' ],
  [ 'bpint', 'int' ],
  [ 'bpdyn', 'java.lang.Object' ],
  [ '__timeStamp', 'java.lang.Long' ], //added by Groovy
] as Set

We can look at a certain field of a class:

assert Math.fields.name as Set == [ 'E', 'PI' ] as Set
assert Math.class.getField('PI').toString() ==
  'public static final double java.lang.Math.PI'
assert Math.class.getField('PI').getDouble() == 3.141592653589793
  //we must know the type of the value

We can also look at the constructors and methods of a class:

assert HashMap.constructors.collect{ it.parameterTypes.name } as Set ==
  [ ['int'], [], ['java.util.Map'], ['int', 'float'] ] as Set
GroovyObject.methods.each{ println it }
  //to print full details of each method of a class
assert GroovyObject.methods.name as Set ==
  ['invokeMethod', 'getMetaClass', 'setMetaClass',
   'setProperty', 'getProperty'] as Set
assert GroovyObject.getMethod('getMetaClass').toString() ==
 'public abstract groovy.lang.MetaClass groovy.lang.GroovyObject.getMetaClass()'

Some code to find out all the getters for a class:

getters= {
  it.methods.name.findAll{ it =~ /^get[A-Z]/ }.
        collect{ it[3].toLowerCase()+it[4..-1] }.join(', ')
}
assert getters( GroovyObject ) == 'metaClass, property'

To see all nested classes for a particular class (eg, of Character):

assert Character.classes.name as Set ==
  [ 'java.lang.Character$Subset', 'java.lang.Character$UnicodeBlock' ] as Set

To query a particular nested class (eg, Character.UnicodeBlock):

Character.UnicodeBlock.fields.name.each{ println it }
  //to list all public constants

Reflecting the Reflection classes themselves

We can use reflection on the reflection classes themselves. For example:

assert Class.methods[0].class == java.lang.reflect.Method
    //find the class of any method of any class...
java.lang.reflect.Method.methods.each{ println it.name }
    //...then find its method names...

//...to help us build a custom-formatted listing of method details
HashMap.class.methods.each{
  println """$it.name( ${it.parameterTypes.name.join(', ')} ) returns \
$it.returnType.name ${it.exceptionTypes.size()>0?'throws ':''}\
${it.exceptionTypes.name.join(', ')}"""
}

We can look at the modifiers of methods and classes:

import java.lang.reflect.Modifier
Modifier.methods.name.sort{}.each{ println it }
  //use reflection on the reflection classes themselves...

//...to help us build a custom-formatted listing of modifier details
[           (ArrayList.getMethod( 'remove', [Object] as Class[] )):
                                              [ 'public' ] as Set,
  (Collections.getMethod( 'synchronizedList', [List] as Class[] )):
                                              [ 'public', 'static' ] as Set,
                                      (Math): [ 'public', 'final' ] as Set,
                               (ClassLoader): [ 'public', 'abstract' ] as Set,
 ].each{ key, val->
  def m= key.modifiers
  def mods= [
    ({Modifier.isPublic(it)}):       'public',
    ({Modifier.isProtected(it)}):    'protected',
    ({Modifier.isPrivate(it)}):      'private',
    ({Modifier.isInterface(it)}):    'interface',
    ({Modifier.isAbstract(it)}):     'abstract',
    ({Modifier.isFinal(it)}):        'final',
    ({Modifier.isStatic(it)}):       'static',
    ({Modifier.isVolatile(it)}):     'volatile',
    ({Modifier.isNative(it)}):       'native',
    ({Modifier.isStrict(it)}):       'strict',
    ({Modifier.isSynchronized(it)}): 'synchronized',
    ({Modifier.isTransient(it)}):    'transient',
  ].collect{ k, v-> k(m)? v: null } as Set
  mods.removeAll( [null] )
  assert mods == val
}

Manipulating Objects

When a class is unknown at compile time (eg, we only have a string representation of a class name), we can use reflection to create objects:

assert Class.forName("java.util.HashMap").newInstance() == [:]

def constructor = Class.forName("java.util.HashMap").
                                   getConstructor( [ int, float ] as Class[] )
assert constructor.toString() == 'public java.util.HashMap(int,float)'
assert constructor.newInstance( 12, 34.5f ) == [:]

We can examine and change public fields for a class refering using a String for the name:

class A{
  public value1
  protected value2
  A( int v ){ value1= v; value2 = v }
}
def a= new A( 100 )
assert A.getField( 'value1' ).get( a ) == 100 //public fields only

try{ A.getField( 'value2' ).get( a ); assert false }
catch(Exception e){ assert e instanceof NoSuchFieldException }

A.getField( 'value1' ).set( a, 350 )
assert a.value1 == 350

And we can call methods using a string for the name:

assert String.getMethod( 'concat', [ String ] as Class[] ).
  invoke( 'Hello, ', [ 'world!' ] as Object[] ) == 'Hello, world!'

Working with Arrays

We can examine and manipulate arrays. To enquire the public array fields of a class:

class A{
  public boolean alive
  public int[] codes
  public Date[] dates
  protected boolean[] states
}
//find all public array fields
def pubFields= new A().class.fields.findAll{ it.type.isArray() }.
                                       collect{ [it.name, it.type.name] }
assert pubFields == [
  [ 'codes', '[I' ], //'[I' means array of int
  [ 'dates', '[Ljava.util.Date;' ], //means array of object java.util.Date
]

To enquire the component type/s of an array:

[             (int[]): [ '[I', 'int' ],
             (Date[]): [ '[Ljava.util.Date;', 'java.util.Date' ],
  (new Date[6].class): [ '[Ljava.util.Date;', 'java.util.Date' ],
                                                           //instantiated class
         (String[][]): [ '[[Ljava.lang.String;', '[Ljava.lang.String;' ],
].each{
  k, v -> assert [ k.name, k.componentType.name ] == v
}

We can create and copy arrays when their component type and size is unknown at compile time:

import java.lang.reflect.Array
def a1 =  [55, 66] as int[]

//component type and size unknown at compile time...
def a2 = Array.newInstance( a1.class.componentType, a1.size() * 2 )
assert a2.class.componentType == int
assert a2.size() == 4
System.arraycopy( a1, 0, a2, 0, a1.size() )
assert a2 as List == [55, 66, 0, 0] as List

We can create multi-dimensional arrays in a similar way, where component type and array sizes can be unknown at compile time:

import java.lang.reflect.Array

//assertion checking code...
assert1D= {x,y->
  assert x.size() == y.size()
  for( int i: x.size() - 1 ) assert x[ i ] == y[ i ]
}
assert2D= {x,y->
  assert x.size() == y.size()
  for( int i: x.size() - 1 ){
    assert x[ i ].size() == y[ i ].size()
    for( int j: x[ i ].size() - 1 ) assert x[ i ][ j ] == y[ i ][ j ]
  }
}

//each is a 1-D int array with 3 elts
def a0= new char[ 3 ]
def a1= Array.newInstance( char, 3 )
def a2= Array.newInstance( char, [ 3 ] as int[] )
assert1D( a0, a1 )
assert1D( a0, a2 )

//both are a 2-D 3x4 array of String elts
def b0= new String[3][4]
def b1= Array.newInstance( String, [ 3, 4 ] as int[] )
assert2D( b0, b1 )

//both are a 2-D array of 6 char arrays, with undefined tail dimension
def c0 = new char[6][]
def c1 = Array.newInstance( char[], [ 6 ] as int[] )
assert1D( c0, c1 )

We can use set() and get() to copy the contents of one array index to another:

import java.lang.reflect.Array
def a= [ 12, 78 ] as int[], b= new int[ 4 ]
Array.set( b, 0, Array.get( a, 0 ) )
assert b[ 0 ] == 12

This tutorial is loosely based on Sun's tutorial on Java Reflection, but using Groovy code instead.