Source code
package com.google.common.reflect;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public final class Reflection {
public static String getPackageName(Class<?> clazz) {
return getPackageName(clazz.getName());
}
public static String getPackageName(String classFullName) {
int lastDot = classFullName.lastIndexOf('.');
return (lastDot < 0) ? "" : classFullName.substring(0, lastDot);
}
public static void initialize(Class<?>... classes) {
for (Class<?> clazz : classes) {
try {
Class.forName(clazz.getName(), true, clazz.getClassLoader());
} catch (ClassNotFoundException e) {
throw new AssertionError(e);
}
}
}
public static <T> T newProxy(Class<T> interfaceType, InvocationHandler handler) {
checkNotNull(handler);
checkArgument(interfaceType.isInterface(), "%s is not an interface", interfaceType);
Object object =
Proxy.newProxyInstance(
interfaceType.getClassLoader(), new Class<?>[] {interfaceType}, handler);
return interfaceType.cast(object);
}
private Reflection() {}
}
Run 1
The code is highly readable with clear structure and organization. Package and imports are properly declared, followed by a single public utility class with well-named methods. Each method has a single, focused purpose: getting package names, initializing classes, and creating proxies. Nesting is minimal—only one try-catch block and one conditional ternary expression. Intent is clear from method names and parameter types. Code length is concise without being cryptic. Most lines contain a single logical action, improving comprehension. The reading flow is natural: package declaration, imports, class definition, then methods in logical order with private constructor at the end. The only minor deduction is for the unnecessary blank lines between methods and the slightly repetitive overloaded getPackageName methods, but these are trivial style preferences. Overall, this code exemplifies clean, maintainable Java utility code.
Run 2
The code is highly readable. It is well-structured into a final class with a private constructor, and methods are logically grouped. Nesting is minimal—only one try-catch block and no deeply nested conditionals. Intent is clear from method names and Javadoc placeholders, though the many empty comment blocks slightly disrupt flow. Code length is concise; methods are short and focused. Action granularity is appropriate, with one main action per line in most cases. The reading flow is natural, moving from simple utility methods to more complex ones. Minor deductions are for the excessive placeholder Javadocs and slightly awkward line breaks in the proxy creation.
Run 3
The code demonstrates excellent readability. Structure is logical, grouping package name utilities, initialization, and proxy creation with clear method separation. Nesting is minimal, with only one loop and try-catch, maintaining flat structure. Intents are clear - method names precisely describe their actions. Code length is concise with no unnecessary verbosity. Most actions are on separate lines, with Proxy.newProxyInstance arguments cleanly distributed. Reading flow follows natural progression from simple to complex operations. The static imports reduce clutter, Javadoc sections provide context, and exception handling is straightforward. Minor deductions for multiple blank lines and slightly dense proxy creation code.
Run 1
Code Structure: Well-organized utility class with focused methods and a private constructor. Nesting: Mostly flat; initialize has a modest loop and try-catch nesting. Clarity of intent: Descriptive method and parameter names make package extraction and proxy creation clear, although initialize requires some knowledge of Java class loading. Code length: Implementations are concise, but excessive blank lines unnecessarily expand the file. Action granularity: Each statement performs a distinct action; the multiline proxy call remains easy to follow. Reading flow: Related overloads are adjacent and method logic proceeds naturally, though inconsistent vertical spacing interrupts scanning.
Run 2
Code Structure: Small, logically separated utility methods provide clear organization. Nesting: Mostly flat; initialize uses a straightforward loop containing try/catch, with manageable depth. Clarity of intent: Descriptive method and parameter names make package extraction, class initialization, and proxy creation understandable, though forced initialization and the AssertionError choice could benefit from brief documentation. Code length: Implementations are concise, but excessive blank lines unnecessarily expand the file. Action granularity: Each statement performs a focused action; the multiline proxy invocation remains easy to follow. Reading flow: Method bodies read naturally, and the private constructor clearly prevents instantiation. However, inconsistent whitespace and large gaps between methods disrupt scanning.
Run 3
Code Structure: Well-organized utility class with focused methods and a private constructor. Nesting: Mostly flat; the loop and try/catch in initialize add only modest depth. Clarity of intent: Descriptive method and parameter names make package extraction and proxy creation clear, though initialize requires familiarity with Class.forName semantics. Code length: Implementations are concise, but excessive blank lines unnecessarily expand the file. Action granularity: Each statement performs a distinct action, and the wrapped proxy call remains readable. Reading flow: Method order and delegation are natural, but irregular whitespace interrupts scanning. Overall, the code is highly readable despite distracting formatting and minor reliance on reflection knowledge.