java 反射 只有get 类 java 反射getmethod参数

  方法反射的基本操作重点就是如何获取方法对象并对方法对象进行反射操作。

1.如何获取某个方法

方法的名称和方法的参数列表唯一的确定一个方法

a)要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型

b) 获取方法 名称和参数列表来决定

获取的是public的方法 ； 其中name是方法名， parameterType是方法参数的类类型。

   getDelcaredMethod()自己声明的方法

2.方法反射的操作

//method.invoke(对象，参数列表)

方法的反射操作是用m对象来进行方法调用

对象，参数列表);方法如果没有返回值返回null,有返回值返回具体的返回值

import java.lang.reflect.Method;

public class MethodDemo1 {
	public static void main(String[] args) {
	   //要获取print(int ,int )方法  1.要获取一个方法就是获取类的信息，获取类的信息首先要获取类的类类型
		A a1 = new A();
		Class c = a1.getClass();
		/*
		 * 2.获取方法 名称和参数列表来决定  
		 * getMethod获取的是public的方法
		 * getDelcaredMethod自己声明的方法
		 */
	    try {
			//Method m =  c.getMethod("print", new Class[]{int.class,int.class});
	    	Method m = c.getMethod("print", int.class,int.class);
	    	
	    	//方法的反射操作  
	    	//a1.print(10, 20);方法的反射操作是用m对象来进行方法调用 和a1.print调用的效果完全相同
	        //方法如果没有返回值返回null,有返回值返回具体的返回值
	    	//Object o = m.invoke(a1,new Object[]{10,20});
	    	Object o = m.invoke(a1, 10,20);
	    	System.out.println("==================");
	    	//获取方法print(String,String)
             Method m1 = c.getMethod("print",String.class,String.class);
             //用方法进行反射操作
             //a1.print("hello", "WORLD");
             o = m1.invoke(a1, "hello","WORLD");
             System.out.println("===================");
           //  Method m2 = c.getMethod("print", new Class[]{});
                Method m2 = c.getMethod("print");
               // m2.invoke(a1, new Object[]{});
                m2.invoke(a1);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} 
     
	}
}
class A{
	public void print(){
		System.out.println("helloworld");
	}
	public void print(int a,int b){
		System.out.println(a+b);
	}
	public void print(String a,String b){
		System.out.println(a.toUpperCase()+","+b.toLowerCase());
	}
}

     方法反射的升华操作（通过反射了解集合泛型的本质）

通过Class， Method来认识泛型的本质  反射的操作都是编译之后的操作。

import java.lang.reflect.Method;
import java.util.ArrayList;

public class MethodDemo2 {
	public static void main(String[] args) {
		ArrayList list = new ArrayList();
		ArrayList<String> list1 = new ArrayList<String>();
		list1.add("hello");
		//list1.add(20);错误的
		Class c1 = list.getClass();
		Class c2 = list1.getClass();
		System.out.println(c1 == c2);//结果为true
		//反射的操作都是编译之后的操作
		/*
		 * c1==c2结果返回true说明编译之后集合的泛型是去泛型化的
		 * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
		 * 绕过编译就无效了
		 * 验证：我们可以通过方法的反射来操作，绕过编译
		 */
		try {
			Method m = c2.getMethod("add", Object.class);
			m.invoke(list1, 20);//绕过编译操作就绕过了泛型
			System.out.println(list1.size());
			System.out.println(list1);
			/*for (String string : list1) {
				System.out.println(string);
			}*///现在不能这样遍历,因为里面不都是String类型，会发生类型转换错误
		} catch (Exception e) {
		  e.printStackTrace();
		}
	}

}