一、Method类的定义
Method类位于 java.lang.reflect 包中，主要用于在程序运行状态中，动态地获取方法信息
二、Method类的常用方法
1、getAnnotatedReturnType()
返回一个AnnotatedType对象，该对象表示使用一个类型来指定由该可执行文件表示的方法/构造函数的返回类型
public class MethodTest {
public String test() {
return null;
}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
AnnotatedType methodAnnotatedReturnType = method.getAnnotatedReturnType();
// class java.lang.String
System.out.println(methodAnnotatedReturnType.getType());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
2、getAnnotatedExceptionTypes()
返回一个AnnotatedType对象数组，这些对象表示使用类型来指定由该可执行文件表示的方法/构造函数声明的异常
public class MethodTest {
public void test() throws NullPointerException, ClassNotFoundException {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
AnnotatedType[] annotatedExceptionTypes = method.getAnnotatedExceptionTypes();
for (AnnotatedType annotatedExceptionType : annotatedExceptionTypes) {
// class java.lang.NullPointerException
// class java.lang.ClassNotFoundException
System.out.println(annotatedExceptionType.getType());
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
3、getAnnotatedReceiverType()
返回一个AnnotatedType对象，该对象表示使用一个类型来指定该可执行对象表示的方法/构造函数的接收者类型
public class MethodTest {
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
AnnotatedType annotatedReceiverType = method.getAnnotatedReceiverType();
// class lang.reflect.MethodTest
System.out.println(annotatedReceiverType.getType());
}
}
1
2
3
4
5
6
7
8
9
10
11
4、getAnnotation(Class<T> annotationClass)
如果该方法对象存在指定类型的注解，则返回该注解，否则返回null
只有类级别的注解会被继承得到，对于其他对象而言，getAnnotation() 方法与 getDeclaredAnnotation() 方法作用相同
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAnnotation {
String key();
String value();
}
public class MethodTest {
@MethodAnnotation(key = "key", value = "value")
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
MethodAnnotation annotation = method.getAnnotation(MethodAnnotation.class);
// @lang.reflect.MethodAnnotation(value=value, key=key)
System.out.println(annotation);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
5、getDeclaredAnnotation(Class<T> annotationClass)
如果该方法对象存在指定类型的注解，则返回该注解，否则返回null
只有类级别的注解会被继承得到，对于其他对象而言，getAnnotation() 方法与 getDeclaredAnnotation() 方法作用相同
6、getAnnotationsByType(Class<T> annotationClass)
如果该方法对象存在指定类型的注解，则返回该注解数组，否则返回null
只有类级别的注解会被继承得到，对于其他对象而言，getAnnotationsByType() 方法与 getDeclaredAnnotationsByType() 方法作用相同
getAnnotationsByType() 方法与 getAnnotation() 方法的区别在于 getAnnotationsByType() 方法会检查修饰该方法对象的注解是否为可重复类型注解，如果是则会返回该参数类型的一个或多个注解
@Repeatable 用于声明注解为可重复类型注解，当声明为可重复类型注解后，如果方法注解仍为一个，则 getAnnotation() 方法会正常返回，如果方法注解为多个，则 getAnnotation()方法会返回null
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Repeatable(RepeatableAnnotation.class)
public @interface MethodAnnotation {
String key();
String value();
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface RepeatableAnnotation {
MethodAnnotation[] value();
}
public class MethodTest {
@MethodAnnotation(key = "key1", value = "value1")
@MethodAnnotation(key = "key2", value = "value2")
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
MethodAnnotation[] annotationsByType = method.getAnnotationsByType(MethodAnnotation.class);
// [@lang.reflect.MethodAnnotation(value=value1, key=key1), @lang.reflect.MethodAnnotation(value=value2, key=key2)]
System.out.println(Arrays.toString(annotationsByType));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
7、getDeclaredAnnotationsByType(Class<T> annotationClass)
如果该方法对象存在指定类型的注解，则返回该注解数组，否则返回null
只有类级别的注解会被继承得到，对于其他对象而言，getAnnotationsByType() 方法与 getDeclaredAnnotationsByType() 方法作用相同
8、getAnnotations()
返回该方法对象上的所有注解，如果没有注解，则返回空数组
只有类级别的注解会被继承得到，对于其他对象而言，getAnnotations() 方法与 getDeclaredAnnotations() 方法作用相同
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAnnotation {
String key();
String value();
}
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TestAnnotation {
String key();
String value();
}
public class MethodTest {
@MethodAnnotation(key = "key1", value = "value1")
@TestAnnotation(key = "key2", value = "value2")
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
Annotation[] annotations = method.getAnnotations();
for (Annotation annotation : annotations) {
// @lang.reflect.MethodAnnotation(value=value1, key=key1)
// @lang.reflect.Parameter.TestAnnotation(key=key2, value=value2)
System.out.println(annotation);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
9、getDeclaredAnnotations()
返回该方法对象上的所有注解，如果没有注解，则返回空数组
只有类级别的注解会被继承得到，对于其他对象而言，getAnnotations() 方法与 getDeclaredAnnotations() 方法作用相同
10、getModifiers()
返回修饰该方法对象修饰符的整数形式，使用 Modifier 类对其进行解码
public class MethodTest {
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
// public
System.out.println(Modifier.toString(method.getModifiers()));
}
}
1
2
3
4
5
6
7
8
9
10
11、getName()
返回方法对象名称
public class MethodTest {
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
// test
System.out.println(method.getName());
}
}
1
2
3
4
5
6
7
8
9
10
12、isAnnotationPresent(Class<? extends Annotation> annotationClass)
如果该方法对象上有指定类型的注解，则返回true，否则为false
public class MethodTest {
@MethodAnnotation(key = "key", value = "value")
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
// true
System.out.println(method.isAnnotationPresent(MethodAnnotation.class));
}
}
1
2
3
4
5
6
7
8
9
10
11
13、isVarArgs()
如果该方法对象的参数中存在 可变参，则返回true，否则为false
public class MethodTest {
public void test(String ... args) {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test", String[].class);
// true
System.out.println(method.isVarArgs());
}
}
1
2
3
4
5
6
7
8
9
10
14、getDeclaringClass ()
返回该方法对象表示的方法所在类的Class对象
public class MethodTest {
public void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
Class<?> declaringClass = method.getDeclaringClass();
// class lang.reflect.MethodTest
System.out.println(declaringClass);
}
}
1
2
3
4
5
6
7
8
9
10
11
15、getAnnotatedParameterTypes()
返回一个AnnotatedType对象数组，这些对象表示使用类型来指定由该可执行文件表示的方法/构造函数的形式参数类型
public class MethodTest {
public void test(String name, Integer age) {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);
AnnotatedType[] annotatedParameterTypes = method.getAnnotatedParameterTypes();
for (AnnotatedType annotatedParameterType : annotatedParameterTypes) {
// class java.lang.String
// class java.lang.Integer
System.out.println(annotatedParameterType.getType());
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
16、getParameterAnnotations()
返回一组注解数组，这些注解以声明顺序修饰该方法对象的参数
public class MethodTest {
public void test(@ParameterAnnotation(key = "key1", value = "value1") String name,
@ParameterAnnotation(key = "key2", value = "value2") Integer age) {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
// [[@lang.reflect.ParameterAnnotation(key=key1, value=value1)], [@lang.reflect.ParameterAnnotation(key=key2, value=value2)]]
System.out.println(Arrays.deepToString(parameterAnnotations));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
17、getParameterCount()
返回该方法对象的参数个数 (无论是显式声明的还是隐式声明的或不声明的)
public class MethodTest {
public void test(String name, Integer age) {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);
// 2
System.out.println(method.getParameterCount());
}
}
1
2
3
4
5
6
7
8
9
10
18、getParameters()
返回一个参数对象数组，该数组表示该方法对象的所有参数
public class MethodTest {
public void test(String name, Integer age) {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test", String.class, Integer.class);
Parameter[] parameters = method.getParameters();
for (Parameter parameter : parameters) {
// java.lang.String name
// java.lang.Integer age
System.out.println(parameter);
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
19、getDefaultValue()
返会该注解方法对象表示的成员默认值
如果成员属于基本数据类型，则返回对应的包装类实例
如果没有默认值或者该方法实例不表示注解方法，则返回null
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MethodAnnotation {
String key() default "default key";
String value() default "default value";
}
public class MethodTest {
public static void main(String[] args) throws Exception {
Method key = MethodAnnotation.class.getMethod("key");
Method value = MethodAnnotation.class.getMethod("value");
Object defaultValue1 = key.getDefaultValue();
Object defaultValue2 = value.getDefaultValue();
// default key
System.out.println(defaultValue1);
// default value
System.out.println(defaultValue2);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
20、getParameterTypes()
返回一个Class对象数组，该数组以声明顺序表示该方法对象的参数对象，会擦除泛型
public class MethodTest<T> {
public void test(T t) {}
public void test(LinkedList<Integer> list) {}
public static void main(String[] args) throws Exception {
Method objectMethod = MethodTest.class.getMethod("test", Object.class);
Method listMethod = MethodTest.class.getMethod("test", LinkedList.class);
Class<?>[] objectParameterTypes = objectMethod.getParameterTypes();
// [class java.lang.Object]
System.out.println(Arrays.toString(objectParameterTypes));
Class<?>[] listParameterTypes = listMethod.getParameterTypes();
// [class java.util.LinkedList]
System.out.println(Arrays.toString(listParameterTypes));
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
21、getReturnType()
返回一个Class对象，该Class对象表示该方法对象的返回对象，会擦除泛型
public class MethodTest<T> {
public T test(T t) {
return t;
}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test", Object.class);
Class<?> returnType = method.getReturnType();
// class java.lang.Object
System.out.println(returnType);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
22、getGenericReturnType()
返回一个Type对象，该Type对象表示该方法对象的返回类型，会保留泛型
public class MethodTest<T> {
public T test(T t) {
return t;
}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test", Object.class);
Type genericReturnType = method.getGenericReturnType();
// T
System.out.println(genericReturnType);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
23、getExceptionTypes()
返回一个Class对象数组，该数组表示由该方法对象抛出的异常对象，会擦除泛型
public class MethodTest<T> {
public <T extends Exception> void test() throws T, NullPointerException {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test");
Class<?>[] exceptionTypes = method.getExceptionTypes();
// [class java.lang.Exception, class java.lang.NullPointerException]
System.out.println(Arrays.toString(exceptionTypes));
}
}
1
2
3
4
5
6
7
8
9
10
11
24、getGenericExceptionTypes()
返回一个Type对象数组，该数组表示由该方法对象抛出的异常类型，会保留泛型
public class MethodTest<T> {
public <T extends Exception> void test() throws T, NullPointerException {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test");
Type[] genericExceptionTypes = method.getGenericExceptionTypes();
// [T, class java.lang.NullPointerException]
System.out.println(Arrays.toString(genericExceptionTypes));
}
}
1
2
3
4
5
6
7
8
9
10
11
25、getTypeParameters()
返回一个TypeVariable对象数组，该数组表示该方法对象声明列表上的类型变量数组
public class MethodTest<T, V> {
public <T, V> void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test");
TypeVariable<Method>[] typeParameters = method.getTypeParameters();
// [T, V]
System.out.println(Arrays.toString(typeParameters));
}
}
1
2
3
4
5
6
7
8
9
10
11
26、toString()
返回该方法对象的字符串表示形式，会擦除泛型
public class MethodTest<T, V> {
public <T, V> void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test");
// public void lang.reflect.MethodTest.test()
System.out.println(method.toString());
}
}
1
2
3
4
5
6
7
8
9
10
27、toGenericString()
返回该方法对象的字符串表示形式，会保留泛型
public class MethodTest<T, V> {
public <T, V> void test() {}
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test");
// public <T,V> void lang.reflect.MethodTest.test()
System.out.println(method.toGenericString());
}
}
1
2
3
4
5
6
7
8
9
10
28、isAccessible()
获取该方法对象的可访问标志
public class MethodTest {
private void test() {}
}
public class Test {
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
// false
System.out.println(method.isAccessible());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
29、setAccessible(boolean flag)
设置该方法对象的可访问标志
在其他类里调用该方法对象时，如果该方法为私有方法，需要设置访问标志为true，否则会报异常
public class MethodTest {
private void test() {}
}
public class Test {
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getDeclaredMethod("test");
method.setAccessible(true);
// test
System.out.println(method.getName());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
30、isDefault()
判断该方法对象是否为默认方法，如果是则返回true，否则为false
public interface Interface {
default void test() {
System.out.println("这是一个默认方法");
}
}
public class MethodTest implements Interface {
public static void main(String[] args) throws Exception {
Method method = MethodTest.class.getMethod("test");
// true
System.out.println(method.isDefault());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
31、isSynthetic()
判断该方法对象是否为合成方法，如果是则返回true，否则为false
在内部类InnerClass中，name是一个私有属性，而我们在外部类MethodTest中，直接引用了这个属性，因此编译器通过生成一个合成方法，用于绕开private私有属性的限制
public class MethodTest {
private class InnerClass {
private String name = "小明";
}
public static void main(final String[] arguments) {
InnerClass innerClass = new MethodTest().new InnerClass();
System.out.println("name: " + innerClass.name);
Method[] declaredMethods = innerClass.getClass().getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
// 【static java.lang.String lang.reflect.MethodTest$InnerClass.access$100(lang.reflect.MethodTest$InnerClass)】 isSynthetic(): true
System.out.println("【" + declaredMethod + "】" + " isSynthetic(): " + declaredMethod.isSynthetic());
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
有关synthetic的相关内容，小伙伴可以看下这里
Java 中冷门的 synthetic 关键字原理解读
32、isBridge()
判断该方法对象是否桥接方法，如果是则返回true，否则为false
桥接方法: 是 JDK1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法
public interface Interface<T> {
T test(T t);
}
public class MethodTest implements Interface<String> {
@Override
public String test(String str) {
return str;
}
public static void main(final String[] arguments) {
Method[] declaredMethods = MethodTest.class.getDeclaredMethods();
for (Method declaredMethod : declaredMethods) {
//【public static void lang.reflect.MethodTest.main(java.lang.String[])】 isBridge(): false
//【public java.lang.String lang.reflect.MethodTest.test(java.lang.String)】 isBridge(): false
//【public java.lang.Object lang.reflect.MethodTest.test(java.lang.Object)】 isBridge(): true
System.out.println("【" + declaredMethod + "】" + " isBridge(): " + declaredMethod.isBridge());
}
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22