Refelection & Java Doc. Practical Tasks

A reflection-based test fails, and the report shows null instead of the reason. That is exactly what you get when you catch the exception from Method.invoke() and print its message:

// in class Calculator: public int divide(int a, int b) { return a / b; }
Method divide = Calculator.class.getMethod("divide", int.class, int.class);
try {
    divide.invoke(new Calculator(), 1, 0);
} catch (InvocationTargetException e) {
    System.out.println(e.getMessage()); // Output: null
    System.out.println(e.getCause());   // Output: java.lang.ArithmeticException: / by zero
}

These Java reflection exercises practice the module «Reflection API and Javadoc in Java»: you will print the structure of a class by its name, write a universal toString() and a DTO mapper that read private fields, load plugins by class name from a properties file, build a mini test runner on top of Method.invoke(), and document a class so that the javadoc command generates HTML without doclint errors. Every task comes with a hint, and the section after the tasks collects the slips that break such solutions most often.

What to Review Before You Start

The five Reflection API tasks need four skills: getting a Class object by name, iterating over fields, constructors and methods with getDeclared*(), and using them through newInstance(), invoke(), get() and set(). The sixth task needs the Javadoc tags and the options of the javadoc command. Each rule is explained with an example in the lesson sections below.

Inspect a Class Structure by Its Name

Write a program that reads a fully qualified class name from the console (for example, shop.Product) and prints the structure of the class:

1. the modifiers and the fully qualified name of the class; choose the word class or interface with isInterface();
2. the superclass and the implemented interfaces;
3. all fields declared in the class: modifiers, type, name;
4. all declared constructors: modifiers and parameter types;
5. all declared methods: modifiers, return type, name and parameter types.

Include private members. Sort fields and methods by name and constructors by the number of parameters; print member types by their simple names (getSimpleName()). If the class does not exist, the program prints Class not found: ... instead of a stack trace.

Test the program on this class:

package shop;

public class Product implements Comparable<Product> {
    public static final int MAX_NAME = 100;
    private String name;
    protected double price;

    public Product() {
    }

    private Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    @Override
    public int compareTo(Product other) {
        return Double.compare(price, other.price);
    }

    private static void log(String message) {
        System.out.println(message);
    }
}

Expected output for the input shop.Product:

public class shop.Product
Superclass: java.lang.Object
Interfaces: java.lang.Comparable
Fields:
  public static final int MAX_NAME
  private String name
  protected double price
Constructors:
  public Product()
  private Product(String, double)
Methods:
  public int compareTo(Product)
  public String getName()
  private static void log(String)

For the input shop.Prodcut: Class not found: shop.Prodcut

Universal toString() with Reflection

Write a class ReflectionToString with a static method String toString(Object obj) that builds a string of the form ClassName{field1=value1, field2=value2} for any object:

1. all fields of the object are printed, including private ones and those inherited from superclasses; superclass fields come first;
2. static fields are not printed — they belong to the class, not to the object;
3. for null the method returns the string null;
4. field values are turned into strings with String.valueOf(); nested objects are not inspected recursively.

Test the method on the Student and Aspirant classes from the exercise «Inheritance: Student and Aspirant». If you solved it, take your own classes, add a research topic field to Aspirant and a static counter of created objects to Student. If not, use these:

class Student {
    private static int count;
    private String firstName;
    private String lastName;
    private String group;
    protected double averageMark;

    Student(String firstName, String lastName, String group, double averageMark) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.group = group;
        this.averageMark = averageMark;
        count++;
    }

    double getScholarship() {
        return averageMark == 5 ? 2000 : 1900;
    }
}

class Aspirant extends Student {
    private String researchWork;

    Aspirant(String firstName, String lastName, String group, double averageMark, String researchWork) {
        super(firstName, lastName, group, averageMark);
        this.researchWork = researchWork;
    }

    @Override
    double getScholarship() {
        return averageMark == 5 ? 2500 : 2200;
    }
}

Student[] students = {
        new Student("Anna", "Smith", "CS-11", 4.5),
        new Aspirant("John", "Brown", "PH-21", 5.0, null)
};
for (Student s : students) {
    System.out.println(ReflectionToString.toString(s));
}
System.out.println(ReflectionToString.toString(null));

Expected output:

Student{firstName=Anna, lastName=Smith, group=CS-11, averageMark=4.5}
Aspirant{firstName=John, lastName=Brown, group=PH-21, averageMark=5.0, researchWork=null}
null

The array element is declared as Student, yet the second line says Aspirant: getClass() returns the actual type of the object, not the type of the variable.

Then override toString() in Student only, with a single line return ReflectionToString.toString(this);, and make sure that System.out.println(s) in the same loop prints the same — Aspirant inherits the method, and its new field still ends up in the string.

Plugin Factory: Load a Class by Name from a Properties File

An application has to plug in string processors (plugins) without knowing their classes at compile time: the class names are stored in a properties file. Create an interface and three classes in the package plugins:

package plugins;

public interface Plugin {
    String execute(String input);
}

package plugins;

public class UpperCasePlugin implements Plugin {
    @Override
    public String execute(String input) {
        return input.toUpperCase();
    }
}

package plugins;

public class ReversePlugin implements Plugin {
    @Override
    public String execute(String input) {
        return new StringBuilder(input).reverse().toString();
    }
}

package plugins;

public class GreetingPlugin implements Plugin {
    private final String greeting;

    public GreetingPlugin(String greeting) {
        this.greeting = greeting;
    }

    @Override
    public String execute(String input) {
        return greeting + ", " + input;
    }
}

The file plugins.properties in the project root:

plugin.1=plugins.UpperCasePlugin
plugin.2=plugins.ReversePlugin
plugin.3=plugins.GreetingPlugin
plugin.4=plugins.Missing
plugin.5=java.lang.StringBuilder

Write a program that:

1. reads the file and goes through the entries in key order;
2. gets the class with Class.forName() and checks that it implements Plugin before creating any object;
3. creates an object with getDeclaredConstructor().newInstance();
4. finds the execute method with getMethod("execute", String.class), calls it through invoke() with the string "Hello" and prints [SimpleClassName] result;
5. prints a separate message for each problem and moves on to the next plugin: ClassNotFoundException, NoSuchMethodException (no constructor without parameters) and a class that does not implement Plugin.

Expected output:

[UpperCasePlugin] HELLO
[ReversePlugin] olleH
No no-arg constructor: plugins.GreetingPlugin
Class not found: plugins.Missing
Not a plugin: java.lang.StringBuilder

DTO Mapper: Copy Fields with Matching Names

Write a class FieldMapper with a method static <T> T copy(Object source, Class<T> targetClass) that creates an object of targetClass and copies field values from source into it:

1. only fields that exist in both classes with the same name and the same type are copied;
2. if the name matches but the type does not, the field is not copied, and the console shows Skipped: name (type -> type);
3. static and final fields are not copied;
4. all other fields of the new object keep their default values.

Test the mapper on these classes:

class User {
    private long id;
    private String login;
    private String passwordHash;
    private int age;

    User(long id, String login, String passwordHash, int age) {
        this.id = id;
        this.login = login;
        this.passwordHash = passwordHash;
        this.age = age;
    }
}

class UserDto {
    private long id;
    private String login;
    private String age;
    private boolean active;

    @Override
    public String toString() {
        return "UserDto{id=" + id + ", login=" + login + ", age=" + age + ", active=" + active + "}";
    }
}

UserDto dto = FieldMapper.copy(new User(7, "anna", "5f4dcc3b", 30), UserDto.class);
System.out.println(dto);

Expected output: passwordHash does not get into the DTO, and age is skipped because the types differ:

Skipped: age (int -> String)
UserDto{id=7, login=anna, age=null, active=false}

Mini Test Runner with Reflection

Write a program that runs the tests of a class whose name is read from the console. A test is a public, non-static method without parameters that returns void and whose name starts with test. All other methods are ignored.

1. Every test is called through invoke() on a new instance of the class.
2. A test passes (PASSED) if the method completes without an exception, and fails (FAILED) if it throws any exception, including AssertionError. For a failed test, print the exception thrown by the test method itself.
3. Tests run in alphabetical order, and a summary is printed at the end.

A test class to check the runner:

public class CalculatorTest {
    public void testAdd() {
        check(2 + 2 == 4, "2 + 2 should be 4");
    }

    public void testSubtract() {
        check(5 - 3 == 1, "5 - 3 should be 1");
    }

    public void testParse() {
        Integer.parseInt("abc");
    }

    public void helper() {            // not a test: the name does not start with test
    }

    public void testWithParam(int x) { // not a test: has a parameter
    }

    public int testReturnsValue() {   // not a test: returns int
        return 1;
    }

    public static void testStatic() { // not a test: static
    }

    private void testPrivate() {      // not a test: not public
    }

    private static void check(boolean condition, String message) {
        if (!condition) {
            throw new AssertionError(message);
        }
    }
}

Expected output for the input CalculatorTest:

PASSED testAdd
FAILED testParse: java.lang.NumberFormatException: For input string: "abc"
FAILED testSubtract: java.lang.AssertionError: 5 - 3 should be 1
Total: 3, passed: 1, failed: 2

Document a Class with Javadoc and Generate HTML

This bank account class is documented with mistakes: the class comment is a regular comment, the names in @param do not match the parameters, the text contains a bare < sign and generics, and the description of withdraw() contradicts the code.

package com.example.bank;

import java.util.ArrayList;
import java.util.List;

/*
 * Bank account
 */
public class Account {

    public static final double MIN_DEPOSIT = 10.0;

    private double balance;
    private final List<String> history = new ArrayList<>();

    /**
     * Creates an account.
     * @param initial the initial balance
     */
    public Account(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        if (amount < MIN_DEPOSIT) {
            throw new IllegalArgumentException("Minimum amount: " + MIN_DEPOSIT);
        }
        balance += amount;
        history.add("+" + amount);
    }

    /**
     * Withdraws money if amount < balance.
     * @param sum the amount
     */
    public double withdraw(double amount) {
        if (amount > balance) {
            throw new IllegalStateException("Insufficient funds");
        }
        balance -= amount;
        history.add("-" + amount);
        return balance;
    }

    /**
     * Returns a List<String> of operations.
     */
    public List<String> getHistory() {
        return List.copyOf(history);
    }
}

1. Put the class into src/com/example/bank/Account.java and generate the documentation with javadoc -d docs -sourcepath src -subpackages com.example -author -version -encoding UTF-8. Save the list of doclint errors and warnings.
2. Turn the class comment into Javadoc: a short first sentence and the tags @author, @version, @since.
3. Document the constant MIN_DEPOSIT so that its value is inserted into the text with the {@value} tag.
4. Fix @param in the constructor and in withdraw(); add @return and @throws wherever they are needed, including unchecked exceptions.
5. Write a comment for deposit(), and in the description of getHistory() link to deposit() and withdraw() with {@link} and state that an unmodifiable copy is returned.
6. Make the description of withdraw() match the code (the whole balance can be withdrawn), and wrap conditions and generics in {@code}.
7. Run the same command again: no error or warning lines must remain in the output. Switching the check off with -Xdoclint:none is not allowed.
8. Open docs/index.html and find on the Account page the author, the version, the value 10.0 in the description of the constant, and the Parameters, Returns and Throws sections.

Where Solutions Break Without a Warning

Reflection code almost always compiles: method and field names are plain strings, and the compiler does not check them. That is why mistakes in these tasks show up only at runtime — as an exception or, worse, as wrong output with no exception at all. The table lists the typical slips from the tasks on this page.