Chapter Notes: Java Reflection

1. Introduction to Java Reflection API

Overview: Java Reflection is a powerful feature that allows a program to inspect and modify its own structure and behavior at runtime. This includes analyzing classes, methods, fields, and constructors, and even changing their values while the program is actively running. This capability is particularly useful for creating dynamic and flexible applications.

Key Uses of Java Reflection:

1. Runtime Inspection:
   • Allows you to examine classes, methods, and fields dynamically.
   • Useful for debugging and testing, as it lets you see the internal state of your program while it is running.
   • Example: You can check variable values, object types, and available methods at runtime.
2. Dynamic Behavior:
   • Enables the creation of instances, method calls, and field access without knowing their names at compile time.
   • This feature makes your code more adaptable, allowing for interactions with classes and methods that might be specified at runtime.
   • Example: Loading new classes and calling their methods dynamically without altering the original code.
3. Frameworks and Libraries:
   • Reflection is used extensively in frameworks like Spring and Hibernate for features such as dependency injection.
   • These frameworks manage object creation and dependencies automatically, reducing the need for repetitive code.
4. Tool Development:
   • Essential for building tools like IDEs or debuggers that offer features like code completion, inspection, and dynamic code modification.
   • Example: An IDE suggesting method names as you type based on reflection.

Important Note: Reflection is powerful but should be used with caution. It can break the normal rules of the program, leading to potential security risks and performance issues.

2. Java Classes and Type Classes

Java Classes:

• A class in Java is a blueprint or prototype from which objects are created.
• It can contain fields (variables), methods, constructors, and nested classes or interfaces.

Example:

public class Car {
    private String color;
    private String model;
    private int speed;

    public Car(String color, String model, int speed) {
        this.color = color;
        this.model = model;
        this.speed = speed;
    }

    public void drive() {
        System.out.println("The car is driving.");
    }

    public void stop() {
        System.out.println("The car has stopped.");
    }

    // Getters and Setters
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
    public String getModel() { return model; }
    public void setModel(String model) { this.model = model; }
    public int getSpeed() { return speed; }
    public void setSpeed(int speed) { this.speed = speed; }
}

Type Classes in Java:

• Java doesn't have type classes like functional programming languages such as Haskell. However, similar behavior can be achieved using interfaces, abstract classes, and generics.
• Type classes allow defining functions that operate on various types, provided those types implement specific behavior.