1.反射系列：Method

https://blog.youkuaiyun.com/zhangquanit/article/details/52927216
Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。
一个完整方法包含的属性有：
方法上使用的注解、方法的修饰符、方法上定义的泛型参数、方法的返回值、方法名称、方法参数(泛型、注解)、方法抛出的异常。
比如下面这个方法：

@MyAnnotation
public <T> boolean add(List<T> list,T...params)throws RuntimeException,Exception{
	if(null==list){
		throw new RuntimeException("list=null");
	}
	
	if(null==params){
		return false;
	}
	//将参数添加到List集合中
	if(null!=params){
		for(T t:params){
			list.add(t);
		}
	}
	return true;
}

注解：@MyAnnotation
修饰符：public
泛型参数：T
返回值：boolean
方法名：add
方法参数(泛型、注解)：List list，T…params
抛出的异常：RuntimeException，Exception

---------------------
package reflect;
 
import java.lang.annotation.Annotation;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.lang.reflect.WildcardType;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
 
/**
 * @author zhangquanit
 */
public class MethodTest {
 
	/**
	 * 一个完整方法包含的属性有： 方法上使用的注解、方法的修饰符、方法上定义的泛型参数、方法的返回值、方法名称、方法参数(泛型、注解)、方法抛出的异常
	 */
	@MyAnnotation
	private <T> boolean add(@MyAnnotation List<T> list, T... params) throws RuntimeException,
			Exception {
		if (null == list) {
			throw new RuntimeException("list=null");
		}
 
		if (null == params) {
			return false;
		}
		// 将参数添加到List集合中
		if (null != params) {
			for (T t : params) {
				list.add(t);
			}
		}
		return true;
	}
 
	public static void main(String[] args) throws Exception {
		// 获取Method
		MethodTest obj = new MethodTest();
		Class<? extends MethodTest> clazz = obj.getClass();
 
		Method method = clazz.getDeclaredMethod("add", List.class,
				Object[].class);
		if (!method.isAccessible()) {
			method.setAccessible(true);
		}
        //获取方法基本信息
		getMethodInfo(method);
		
		// 调用方法
		List<String> arrayList = new ArrayList<String>();
		method.invoke(obj, arrayList, new String[] { "1", "2" });
		System.out.println(arrayList);//[1,2]
		
		//方法定义所在的类
		Class<?> declaringClass = method.getDeclaringClass();
		
		// 如果此方法是 bridge 方法，则返回 true；
		boolean bridge = method.isBridge();
		//如果该方法是public非抽象非静态，且定义在接口中，则返回true
		boolean default1 = method.isDefault(); //false
		//如果此方法为复合方法，则返回 true；
		boolean synthetic = method.isSynthetic();//false
		// 如果将此方法的参数带有可变参数，则返回 true
		boolean varArgs = method.isVarArgs(); //true
		
		
		
	}
 
	private static void getMethodInfo(Method method) {
		// 1、获取方法上的注解
		boolean annotationPresent = method
				.isAnnotationPresent(MyAnnotation.class);
		if (annotationPresent) {
			MyAnnotation myAnnotation = method
					.getDeclaredAnnotation(MyAnnotation.class);
		}
		// 2、方法的修饰符
		int modifiers = method.getModifiers();
		String modify = Modifier.toString(modifiers);// private
		// 3、方法上定义的泛型参数
		TypeVariable<Method>[] typeParameters = method.getTypeParameters();// [T]
		// 4、方法的返回值
		Class<?> returnType = method.getReturnType();// boolean
		Type genericReturnType = method.getGenericReturnType();// boolean
		// 5、方法名称
		String name = method.getName();
		// 6、方法参数
		int parameterCount = method.getParameterCount();// 参数个数 2
		// 方法参数——泛型
		Class<?>[] parameterTypes = method.getParameterTypes();
		// 打印 [interface java.util.List, class [Ljava.lang.Object;]
		Type[] genericParameterTypes = method.getGenericParameterTypes();
		// 打印 [java.util.List<T>, T[]]
		for (Type type : genericParameterTypes) {
			if (type instanceof ParameterizedType) { // 参数类型
				System.out.println("ParameterizedType类型：" + type);
				ParameterizedType parameterizedType = (ParameterizedType) type;
				Type[] actualTypeArguments = parameterizedType
						.getActualTypeArguments();
				System.out.println("实际参数为："
						+ Arrays.toString(actualTypeArguments));
				for (Type actualType : actualTypeArguments) {
					if (actualType instanceof WildcardType) {
						WildcardType wildcardType = (WildcardType) actualTypeArguments[0];
						System.out.println("实际参数为WildcardType类型："
								+ wildcardType.getUpperBounds());
					} else if (actualType instanceof Class) {
						System.out.println("实际参数为Class类型：" + actualType);
					}
				}
 
			} else if (type instanceof GenericArrayType) { // 泛型数组类型 T[]
				GenericArrayType genericArrayType = (GenericArrayType) type;
				System.out.println("GenericArrayType类型："
						+ genericArrayType.getGenericComponentType());//T
			} else if (type instanceof TypeVariable) { // 泛型变量
				System.out.println("TypeVariable类型：" + type);
			} else if (type instanceof Class) { //
				System.out.println("Class类型：" + type);
			}
		}
		/*
		 * 方法有2个参数，第一个参数list为ParameterizedType，实际参数为T，
		 * 第二个参数为GenericArrayType泛型数组类型T[],数组元素类型为T
		 */
		
		//方法参数——注解   第一个参数使用了注解
		Annotation[][] parameterAnnotations = method.getParameterAnnotations();
		Annotation myAnnotation=parameterAnnotations[0][0];
		//打印 @reflect.MyAnnotation(intValue=0)
		
 
		// 7、方法抛出的异常
		Class<?>[] exceptionTypes = method.getExceptionTypes();
		// 打印 [class java.lang.RuntimeException, class java.lang.Exception]
		Type[] genericExceptionTypes = method.getGenericExceptionTypes();
		// 打印 [class java.lang.RuntimeException, class java.lang.Exception]
 
	}
}