Reflection: Constructor, Method & Field

From the Class object to its members

A Class object is the gateway; the java.lang.reflect package — Constructor, Method, Field — is what you do with it. Reflection means inspecting and using a type's members at runtime, with no compile-time knowledge of which type it is. This is how frameworks build objects whose class names live in a config file, and it is exactly the mechanism the Greenhouse project's Part 2 needs.

The Greenhouse event factory — build an Event by its name

In the control system, every event extends abstract class Event and shares one constructor signature: Event(long delayTime). The subclasses LightOn, WaterOff, Bell, Terminate… all call super(delayTime). An event file contains lines naming events to schedule. The goal is to add a brand-new event type without recompiling the controller — so the controller must turn a name string into an object:

import java.lang.reflect.Constructor;

public static Event create(String name, long time) throws Exception {
    Class<?> c = Class.forName(name);                 // e.g. "events.LightOn"
    Constructor<?> ctor = c.getConstructor(long.class); // the Event(long) ctor
    return (Event) ctor.newInstance(time);            // call it -> a live Event
}

Step by step:

1. Class.forName(name) loads the class named by the string and returns its Class object. If no such class exists, it throws ClassNotFoundException.
2. getConstructor(long.class) looks up the public constructor whose parameter list is exactly (long). Note the primitive class literal long.class — Long.class would not match a long parameter. If there is no matching public constructor it throws NoSuchMethodException.
3. ctor.newInstance(time) actually calls that constructor with the argument time, returning a new Object, which we cast to Event. (The cast can throw ClassCastException at runtime if the named class is not an Event.)

Adding a new event type — say FansOn — now means writing one class and dropping its name in the file; the controller code never changes. That decoupling is the whole point of the exam question "how do you add a class without recompiling?".

Invoking a method and reading a field reflectively

import java.lang.reflect.Method;
import java.lang.reflect.Field;

Method m = c.getMethod("action");      // public no-arg method named "action"
m.invoke(obj);                         // calls obj.action()

Method g = c.getMethod("setRings", int.class);
g.invoke(obj, 5);                      // calls obj.setRings(5)

Field f = c.getDeclaredField("light"); // any access level, declared on c
f.setAccessible(true);                 // bypass private access
boolean on = (boolean) f.get(obj);     // read the field's value

getMethod / getConstructor see only public members (including inherited ones); the getDeclared* variants see members of any access level declared by that class but not inherited ones. To touch a non-public member you must call setAccessible(true) first.