Item Prefer interfaces over reflection

Reflection in Java (java.lang.reflect):
Through reflection, it is possible:

• Programmatically access constructors, methods, and fields of arbitrary classes.
• Manipulate classes and their members (constructors, methods, fields) in a reflective way, allowing you to create instances, invoke methods and access fields.
• Invoke methods on objects even if the classes do not exist during compilation.

Disadvantages of Reflection:
Loss of compile-time type checking:

• Errors that would normally be detected at compilation will only appear at run time.
• Example: Reflexively invoking a non-existent or inaccessible method may generate exceptions at runtime.

Heavy and verbose code:
Reflection requires more complex and less readable code.
Example:

Method method = obj.getClass().getMethod("methodName");
method.invoke(obj, args);

Underperformance:

• Reflective method invocation is considerably slower than normal invocation.
• Example: in certain scenarios, reflection can be up to 11 times slower than direct method invocation.

Applications of Reflection:

• Used in code analysis tools, dependency injection frameworks and service provider frameworks.
• Even in these contexts, it should be avoided when possible due to its disadvantages.

Limited use of reflection:
Suggested technique: Use reflection only to instantiate unknown classes at compile time, and reference these instances through known interfaces or superclasses.

Example:
Program that creates instances of Set, specified by the command line:

Class<? extends Set<String>> cl = (Class<? extends Set<String>>) Class.forName(args[0]);
Constructor<? extends Set<String>> cons = cl.getDeclaredConstructor();
Set<String> s = cons.newInstance();
for (int i = 1; i < args.length; i++) {
    s.add(args[i]);
}
System.out.println(s);

Disadvantages illustrated in the example:
Runtime Exceptions:

• The example can generate up to six different exceptions at run time.
• These exceptions would be caught at compile time if reflection were not used.

Complexity and verbosity:

• The example requires 25 lines of code to instantiate a class from its name, while a direct constructor call would be done in just one line.

Unverified cast warning:

• In the example, there is a legitimate warning of unchecked cast, as the class specified on the command line may not be an implementation of Set.

Legitimate use of reflection:

• Dynamic dependencies: when a class, method or field may not exist at run time.
• Example: You can use reflection to support multiple versions of a package without breaking backwards compatibility.

Conclusion:
Reflection is powerful, but it has many disadvantages.
Whenever possible, use reflection only to instantiate objects and access them through interfaces or superclasses known at compile time.

Example from the book:

The above is the detailed content of Item Prefer interfaces over reflection. For more information, please follow other related articles on the PHP Chinese website!