Understanding Java Reflection and Class Loading Mechanisms

1. Using the Class class

In Java everything is an object, and each class itself is an instance of java.lang.Class. The Class instance can be obtained without explicit new because its constructor is private.

There are three ways to get a Class object for a class (e.g., Student):

Class c1 = Student.class; // using the class literal

Class c2 = stu.getClass(); // from an existing object

Class c3 = Class.forName("full.class.Name"); // by name, may throw ClassNotFoundException

c1 and c2 refer to the same Class object, so System.out.println(c1 == c2); prints true.

Instances can be created via the Class object when a no‑argument constructor is present:

Student stu = (Student) c1.newInstance();

2. Dynamic class loading

Static (compile‑time) loading requires all referenced classes to be present during compilation. Dynamic (runtime) loading uses Class.forName to load a class only when it is needed, allowing updates without recompilation.

3. Obtaining method information

Methods are identified by their name and parameter types. To retrieve a specific method:

Method m = c.getDeclaredMethod("methodName", ParameterType1.class, ParameterType2.class);

To invoke the method:

Object result = m.invoke(targetObject, arg1, arg2);

If the method returns a value, it is returned as an Object and must be cast to the appropriate type.

4. Accessing fields and constructors

Class API also provides methods to retrieve fields, constructors, interfaces, packages, annotations, etc. (details omitted for brevity).

5. Reflection and generics

Generic type information is erased after compilation. Using reflection, one can add elements of any type to a generic collection at runtime, which may lead to ClassCastException when iterating.

6. Java class loader details

When a class is first used, the JVM loads it through three steps: loading, linking, and initialization.

Loading reads the .class file and creates a Class object.

Linking includes verification, preparation (allocating static fields), and resolution (replacing symbolic references).

Initialization runs static initializers and assigns default values.

Class loading occurs in the following situations: creating an instance, accessing a static field, invoking a static method, using reflection, subclass initialization, or launching via java command.

There are three primary class loaders:

Bootstrap ClassLoader – loads core Java classes from rt.jar .

Extension ClassLoader – loads classes from the JRE's lib/ext directory.

System (Application) ClassLoader – loads classes from the classpath, typically the application’s own classes.

Understanding these mechanisms helps developers grasp how Java programs are executed and how reflection can be leveraged effectively.