<think>我们分析每个选项，重点关注第3步（获取Method对象）和第4步（调用方法）的正确性。
题目中test方法的签名是：public int test(int p1, Integer p2)
注意：
1. 第一个参数是基本类型int，第二个参数是Integer类型。
2. 在反射中，基本类型需要使用对应的Class对象，如int.class，而引用类型使用包装类.class或直接使用包装类的类型。
选项分析：
选项1：
3. Method testMethod = classType.getMethod("test", new Class[] {int.class, int.class});
这里第二个参数指定为int.class，但是原方法的第二个参数是Integer类型。虽然Java有自动拆箱装箱，但在反射中，参数类型必须精确匹配。
因此，这里应该使用Integer.class而不是int.class。所以这一步会抛出NoSuchMethodException。
4. 调用时传递的是两个Integer对象，这虽然可以自动拆箱，但由于方法签名不匹配，第3步已经出错，所以整个选项错误。
选项2：
3. Method testMethod = classType.getMethod("test", new Class[] {int.class, int.class});
同样，第二个参数应该是Integer.class，而不是int.class。所以这一步也会出错。
选项3：
3. Method testMethod = classType.getMethod("test", new Class[] {int.class, Integer.class});
这里参数类型完全匹配：第一个是int（基本类型），第二个是Integer（包装类）。所以这一步正确。
4. Integer result = testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)});
这里有两个问题：
a. 方法的返回类型是int（基本类型），而这里用Integer接收。虽然可以自动装箱，但是invoke方法返回的是Object，需要先转换为Integer，然后自动拆箱赋值给int？但这里声明的是Integer，所以可以接收（因为int返回值会被自动装箱成Integer）。
b. 但是，invoke方法返回的是Object，这里直接赋值给Integer（没有强制转换）会编译错误吗？
实际上，Java允许将Object强制转换为Integer，但这里没有显式转换，所以编译错误吗？
注意：在Java中，我们不能直接将Object赋值给Integer（需要强制转换），但是这里在赋值时，编译器知道testMethod.invoke返回的是Object，而Integer是Object的子类，所以需要强制转换。因此，这行代码应该写成：
Integer result = (Integer) testMethod.invoke(tester, ...);
c. 另外，还有一个问题：test方法返回的是int，而invoke方法返回的是Object（实际上是Integer，因为基本类型返回值会被自动装箱）。但是由于我们声明的是Integer，所以可以接收，但需要强制转换（从Object到Integer）。
所以第4行应该是：
Object resultObj = testMethod.invoke(tester, new Object[]{new Integer(100), new Integer(200)});
int result = (Integer) resultObj; // 或者直接使用Integer接收，但需要强制转换
或者：
Integer result = (Integer) testMethod.invoke(...);
但是原代码没有强制转换，所以会编译错误（除非使用泛型来避免强制转换，但这里没有使用泛型获取Method）。
因此，选项3的第4行有问题。
选项4：
1. Class<Tester> classType = Tester.class; // 这里使用了泛型，正确
2. Object tester = classType.newInstance(); // 正确创建实例
3. Method testMethod = classType.getMethod("test", new Class[] {int.class, Integer.class}); // 参数类型正确
4. Object result = testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)});
这里调用正确：
- 参数传递：两个Integer对象，第一个参数会自动拆箱为int，第二个就是Integer，符合方法签名。
- 返回值处理：方法返回int，但invoke返回的是包装后的Integer（自动装箱），然后赋值给Object（因为Object可以接收任何对象）。所以这一步正确。
因此，选项4是完全正确的。
但是，选项4的第3行有一个拼写错误吗？注意：
3. Method testMethod = ClassType.getMethod(...); // 应该是classType（小写c），而不是ClassType（这里大写了C）
在代码中，变量名是classType（小写开头），而这里写成了ClassType（大写开头），这是一个编译错误。
所以，如果选项4的第3行是：
Method testMethod = classType.getMethod(...); // 使用小写的classType
那么就是正确的。
但根据题目给出的文本：
3. Method testMethod = ClassType.getMethod("test", new Class[] {int.class, Integer.class});
这里写的是ClassType（首字母大写），而变量名是classType（首字母小写），所以这里会出现编译错误（除非有一个名为ClassType的变量或类）。
因此，我们需要检查选项4的变量命名：
第1行：Class<Tester> classType = Tester.class; // 变量名为classType
第3行：ClassType.getMethod // 应该是classType.getMethod
所以，选项4的第3行有拼写错误，应该改为classType.getMethod。
但是，题目中给出的选项4的第3行是“ClassType”，所以如果严格按题目，这个选项有错误。
然而，我们再看题目中给出的四个选项，第三个选项的结尾有个字母'a'，第四个选项没有给出完整，可能是笔误。
重新审视题目给出的选项4：
1. Class<Tester> classType - Tester.class; // 注意这里赋值用的是减号？应该是等号。题目中写的是减号，但可能是笔误，通常我们用等号。
2. Object tester - classType.newInstance(); // 同样，用减号赋值？
3. Method testMethod = ClassType.getMethod(...); // 应该是classType，但写成了ClassType
所以题目中的选项4有多处错误（赋值运算符错误和变量名错误）。
那么，现在哪个选项正确？
重新考虑选项3：
3. Method testMethod = classType.getMethod("test", new Class[] {int.class, Integer.class}); // 正确
4. Integer result = testMethod.invoke(...); // 这里需要强制转换
但是，在Java中，从Object到Integer的转换不是自动的，必须显式转换。因此，选项3的第4行应该改为：
Integer result = (Integer) testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)});
而题目中没有强制转换，所以选项3的第4行会编译错误（类型不匹配：Object不能直接转换为Integer）。
因此，严格来说，没有一个选项是完全正确的。但是，如果我们允许修正一些明显的笔误，那么选项4（修正变量名后）是正确的。
然而，在题目给出的原始文本中，选项3的第4行是：
4. Integer result - testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)});
这里赋值也是用减号，应该是笔误，应该是等号。而且，即使等号，也需要强制转换。
选项4的第4行是：
4. Object result = testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)});
这里没有类型转换问题，因为invoke返回Object，用Object接收是安全的。
所以，如果我们忽略赋值运算符的笔误（将减号视为等号），并且忽略选项4第3行的变量名拼写错误（将ClassType视为classType），那么选项4正确。
但是，选项4的第1行和第2行也是用减号赋值，所以整个选项4的赋值写法都是错误的（应该用等号）。
因此，我们需要寻找一个没有语法错误且逻辑正确的选项。
重新审视，选项1、2、3、4中，只有选项3在第3步是正确的（方法签名匹配），而第4步虽然声明为Integer，但缺少强制转换。如果我们修正第4步（加上强制转换）和赋值运算符，那么选项3就正确了。
但是题目要求我们选择“哪段代码能正确地动态调用”，而给出的四个选项都有问题。
我们再看选项3的修正版：
1. Class classType = Tester.class; // 正确
2. Object tester = classType.newInstance(); // 使用等号
3. Method testMethod = classType.getMethod("test", new Class[] {int.class, Integer.class}); // 正确
4. Integer result = (Integer) testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)}); // 加上强制转换
这样就是正确的。
但是题目中选项3的第4行并没有强制转换，所以原选项3错误。
选项4的第4行使用Object接收，没有强制转换，所以正确（只是接收类型不同，但我们不需要知道具体类型时，可以用Object接收）。但是选项4的第3行有变量名错误，第1、2行赋值运算符错误。
因此，如果必须从原题中选一个，那么选项4（修正变量名和赋值运算符后）是最接近正确的。
然而，我们注意到题目中选项3的第4行是“Integer result -”，而选项4的第4行是“Object result =”，所以选项4的第4行写法正确（除了变量名）。
综合考虑，选项4的第3行有拼写错误（ClassType应该为classType），其他行也有赋值运算符错误（减号应该为等号）。但选项3的第4行有类型转换问题。
所以，我们选择哪一个？
实际上，在反射中，我们通常用Object接收返回值，然后再转换为具体类型（如果需要）。所以选项4的第4行用Object接收是常见的做法，没有问题。而选项3的第4行试图用Integer接收，但没有强制转换，所以会编译失败。
因此，如果忽略选项4的拼写错误和赋值运算符错误，选项4正确。但是，严格按代码，选项4有语法错误。
根据题目的描述，我们可能认为选项4是正确答案（如果我们修正了这些笔误）。
但是，请注意题目中选项3的末尾有一个字母'a'，可能是编号标记，而选项4没有写完整（有省略）。所以，我们只能根据给出的文字判断。
结论：
从逻辑上，只有选项4的第3行（修正拼写错误后）和第4行在类型上是正确的，而选项3的第3行正确但第4行错误。
所以，如果题目中选项4的第3行是：
Method testMethod = classType.getMethod(...); // 使用正确的变量名
那么选项4正确；否则，没有正确选项。
由于题目中选项4的第3行确实写的是“ClassType”，所以严格来说，选项4不正确。
但如果我们假设题目中的笔误，那么选项4是唯一可能正确的。
然而，题目中还有另一个选项3，它的第3行也有一个字母'a'，可能是编号，也可能是拼写错误。我们再看：
选项3的第3行：Method testMethod = classType.getMethod("test", new Class[] {int.class, Integer.class});a
最后多了一个字母'a'，这可能是笔误。
所以，综合来看，题目中的四个选项都有笔误。但我们必须在其中选择。
重新整理，实际上正确的反射调用代码应该是：
Class classType = Tester.class;
Object tester = classType.newInstance();
Method testMethod = classType.getMethod("test", int.class, Integer.class); // 也可以不用数组，用可变参数
Object result = testMethod.invoke(tester, 100, 200); // 注意：这里也可以传入基本类型和包装类型，因为会自动装箱拆箱；而且也可以使用自动装箱和可变参数简化
或者：
Object result = testMethod.invoke(tester, new Object[]{100, 200}); // 100会自动装箱为Integer，然后匹配test方法的第一个int参数会拆箱，第二个参数是Integer，直接匹配
所以，我们比较选项4：
第3行：classType.getMethod("test", new Class[] {int.class, Integer.class}) // 正确
第4行：Object result = testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)}); // 正确
但是，第3行写成了ClassType，所以错误。
选项3的第3行：使用了正确的classType，但是第4行错误（没有强制转换且用Integer接收）。
因此，如果题目中选项4的第3行是classType，则选D；否则，没有正确选项。
由于题目中明确写了选项4的第3行是“ClassType”，所以不能选。
那么，我们再看题目有没有其他选项？题目一共四个选项，我们分析完了。
但是，我们注意到题目中选项3的第4行是“Integer result -”，这里赋值运算符是减号，可能是等号的笔误。而且，如果我们将减号视为等号，那么这一行缺少强制转换，会编译失败。
所以，最终结论：没有一个选项是完全正确的。
但是，如果我们放宽要求，允许修正明显的笔误，那么：
选项3：修正第4行，将减号改为等号，并加上强制转换，即：
Integer result = (Integer) testMethod.invoke(...);
或者，选项4：修正第1、2行的减号为等号，第3行将ClassType改为classType，即：
Class<Tester> classType = Tester.class;
Object tester = classType.newInstance();
Method testMethod = classType.getMethod("test", new Class[] {int.class, Integer.class});
Object result = testMethod.invoke(tester, new Object[] {new Integer(100), new Integer(200)});
那么修正后的选项4更符合常规反射代码（因为我们通常用Object接收invoke的返回值）。
因此，答案可能是选项4，但需要修正笔误。
由于题目要求选择，我们认为选项4是正确答案（假设笔误被修正）。
所以，正确答案是选项4。
</think>### Java反射方法调用分析
问题核心：通过反射正确调用`Tester.test(int, Integer)`方法。以下是各选项的详细分析：
#### 正确答案：第四个选项（修复语法错误后）
```java
import java.lang.reflect.Method;
class Tester {
public int test(int p1, Integer p2) {
return p1 + p2;
}
}
public class ReflectionExample {
public static void main(String[] args) throws Exception {
// 1. 获取Class对象（泛型版本更安全）
Class<Tester> classType = Tester.class;
// 2. 创建实例
Tester tester = classType.newInstance();
// 3. 获取方法（参数类型精准匹配）
Method testMethod = classType.getMethod(
"test",
int.class, // 基本类型
Integer.class // 包装类型
);
// 4. 调用方法（自动拆箱装箱）
Object result = testMethod.invoke(
tester,
new Object[] {
new Integer(100), // 自动拆箱为int
new Integer(200) // 保持Integer类型
}
);
System.out.println("Result: " + result); // 输出300
}
}
```
#### 各选项错误解析
1. **第一/二个选项错误**：
```java
Method testMethod = classType.getMethod("test",
new Class[] {int.class, int.class}); // 错误
```
- ❌ 参数类型不匹配：实际方法第二个参数是`Integer`，但这里用了`int.class`
- 🤯 抛出`NoSuchMethodException`
2. **第三个选项错误**：
```java
Integer result = testMethod.invoke(...); // 错误
```
- ❌ 类型转换错误：`invoke()`返回`Object`，不能直接赋值给`Integer`
- 💥 编译错误：需要强制类型转换`(Integer)`
3. **第四个选项问题修正**：
- 原代码有语法错误：
- `Class<Tester> classType - Tester.class;` → 应改为`=`
- `Method testMethod = ClassType.getMethod(...)` → 应改为`classType`
- 修正后完全正确：
- ✅ 参数类型精准匹配（`int.class + Integer.class`）
- ✅ 返回值用`Object`接收（推荐方式）
- ✅ 参数传递正确（自动拆箱机制）
#### 反射关键点解析
1. **方法签名匹配**：
```java
getMethod("test", int.class, Integer.class)
```
- 必须精确匹配原始方法签名
- 基本类型用`int.class`，对象类型用`Integer.class`
2. **自动类型转换**：
| 传递参数类型 | 方法参数类型 | 结果 |
|--------------|-------------|------------|
| `Integer` | `int` | 自动拆箱 ✅ |
| `Integer` | `Integer` | 直接匹配 ✅ |
| `int` | `Integer` | 自动装箱 ✅ |
3. **返回值处理**：
```java
Object result = method.invoke(...);
int intResult = (int) result; // 手动拆箱
Integer integerResult = (Integer) result; // 强制转换
```
#### 反射最佳实践
```java
// 安全通用调用模板
public static Object callMethod(Object target, String methodName,
Class<?>[] paramTypes, Object... args) {
try {
Method method = target.getClass().getMethod(methodName, paramTypes);
return method.invoke(target, args);
} catch (Exception e) {
throw new RuntimeException("Reflection call failed", e);
}
}
// 调用示例
int result = (int) callMethod(
new Tester(),
"test",
new Class[]{int.class, Integer.class},
100, // 自动装箱Integer.valueOf(100)
200 // 自动装箱Integer.valueOf(200)
);
```
本文通过一个Java示例程序探讨了如何使用反射机制调用一个方法。特别关注了如何正确指定参数类型来避免NoSuchMethodException异常，并解释了int.class与Integer.class的区别。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
