目录：

1.访问方法(Method)对象的方法汇总

2.获取方法(Method)对象中的值

3.设置方法(Method)对象中的值

1.访问Method的方法汇总

以下四种方法在Class类可以返回关于字段的 Method 对象。

Method getMethod(name, Class...)：获取某个public的Method(包括父类)

Method getDeclaredMethod(name, Class...)：获取当前类的某个Method(不包括父类)

Method[] getMethods()：获取所有public的Method(包括父类)

Method[] getDeclaredMethods()：获取当前类的所有Method(不包括父类)

使用示例：

public class Main {

public static void main(String[] args) throws Exception {

Class stdClass = Student.class;

// 获取public方法getScore，参数为String:

System.out.println(stdClass.getMethod("getScore", String.class));

// 获取继承的public方法getName，无参数:

System.out.println(stdClass.getMethod("getName"));

// 获取private方法getGrade，参数为int:

System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));

}

}

class Student extends Person {

public int getScore(String type) {

return 99;

}

private int getGrade(int year) {

return 1;

}

}

class Person {

public String getName() {

return "Person";

}

}

输出信息如下：

public int Student.getScore(java.lang.String)

public java.lang.String Person.getName()

private int Student.getGrade(int)

一个Method对象包含一个方法的所有信息：

getName()：返回方法名称，例如："getScore"；

getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；

getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；

getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。

2.调用public的非静态方法

import java.lang.reflect.Method;

public class MethodMain {

public static void main(String[] args) throws Exception {

//1.采用传统方法访问substring()方法

String str1 = "Hello world1";

String res1 = str1.substring(6); // "world1"

System.out.println(res1);

// 2.采用反射访问substring()方法

String str2 = "Hello world2";

// 获取public String substring(int beginIndex) 方法，参数为int类型:

Method method = String.class.getMethod("substring", int.class);//这里需要传入int.class即参数的Class类

// 在s对象上调用该方法并获取结果:

String res2 = (String) method.invoke(str2, 6);//invoke(Object obj, Object... args)

// 打印调用结果:

System.out.println(res2);//"world2"

}

}

注意到substring()有两个重载方法，我们获取的是String substring(int)这个方法。

对Method实例调用invoke就相当于调用该方法，invoke的第一个参数是对象实例，即在哪个实例上调用该方法，后面的可变参数要与方法参数一致，否则将报错。

3.调用非public的非静态方法

public class Main {

public static void main(String[] args) throws Exception {

Person p = new Person();

Method m = p.getClass().getDeclaredMethod("setName", String.class);

m.setAccessible(true);//访问非public方法，需要在这里设置一下，否则会报错IllegalAccessException

m.invoke(p, "Bob");

System.out.println(p.name);

}

}

class Person {

String name;

private void setName(String name) {

this.name = name;

}

}

4.访问静态方法

public class Main {

public static void main(String[] args) throws Exception {

// 获取Integer.parseInt(String)方法，参数为String:

Method m = Integer.class.getMethod("parseInt", String.class);

// 调用该静态方法并获取结果:

Integer n = (Integer) m.invoke(null, "12345");//如果获取到的Method表示一个静态方法，调用静态方法时，由于无需指定实例对象，所以invoke方法传入的第一个参数永远为null。我们以Integer.parseInt(String)为例：

// 打印调用结果:

System.out.println(n);

}

}

5.多态方法的调用

假设：一个Person类定义了hello()方法，并且它的子类Student也覆写了hello()方法，那么，从Person.class获取的Method，作用于Student实例时，调用的方法到底是哪个？

public class Main {

public static void main(String[] args) throws Exception {

// 获取Person的hello方法:

Method h = Person.class.getMethod("hello");

// 对Student实例调用hello方法:

h.invoke(new Student());//输出：Student:hello

}

}

class Person {

public void hello() {

System.out.println("Person:hello");

}

}

class Student extends Person {

public void hello() {

System.out.println("Student:hello");

}

}

运行上述代码，发现打印出的是Student:hello，因此，使用反射调用方法时，仍然遵循多态原则：即总是调用实际类型的覆写方法(如果存在)。

反射代码：

Method m = Person.class.getMethod("hello");

m.invoke(new Student());

相当于：

Person p = new Student();

p.hello();//多态