java反射学习总结

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.youkuaiyun.com/u010741376/article/details/47904691

一。Class类的使用

    1. 在面向对象的世界里，万事万物皆对象。（java语言中，静态的成员、普通数据类型除外)
   类是不是对象呢?类是(哪个类的对象呢?)谁的对象呢?
   类是对象，类是java.lang.Class类的实例对象

   2. Class.forName("类的全称")
       不仅表示了，类的类类型，还代表了动态加载类
       请大家区分编译、运行
       编译时刻加载类是静态加载类、运行时刻加载类是动态加载类
  3.  基本的数据类型
      void关键字  都存在类类型
    

具体看代码：

package com.reflect.util;

public class ClassDemo {
     public static void main(String[] args) {
    	//Foo的实例对象如何表示
 		Foo foo1 = new Foo();//foo1就表示出来了.
 		//Foo这个类 也是一个实例对象，Class类的实例对象,如何表示呢
 		//任何一个类都是Class的实例对象，这个实例对象有三种表示方式
 		
 		//第一种表示方式--->实际在告诉我们任何一个类都有一个隐含的静态成员变量class
 		Class c1 = Foo.class;
 		
 		//第二中表达方式  已经知道该类的对象通过getClass方法
 		Class c2 = foo1.getClass();
 		
 		/*官网 c1 ,c2 表示了Foo类的类类型(class type)
 		 * 万事万物皆对象，
 		 * 类也是对象，是Class类的实例对象
 		 * 这个对象我们称为该类的类类型
 		 * 
 		 */
 		
 		//不管c1  or c2都代表了Foo类的类类型，一个类只可能是Class类的一个实例对象
 		System.out.println(c1 == c2);
 		
 		//第三种表达方式
 		Class c3 = null;
 		try {
 			c3 = Class.forName("com.reflect.util.Foo");
 		} catch (ClassNotFoundException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 		System.out.println(c2==c3);
 		
 		//我们完全可以通过类的类类型创建该类的对象实例---->通过c1 or c2 or c3创建Foo的实例对象
 		try {
 			Foo foo = (Foo)c1.newInstance();//需要有无参数的构造方法
 			foo.print();
 		} catch (InstantiationException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		} catch (IllegalAccessException e) {
 			// TODO Auto-generated catch block
 			e.printStackTrace();
 		}
 	
	}
}
class Foo{
	void print(){
		System.out.println("foo");
	}
}

二。通过反射获取成员函数

  public static void printClassMethodMessage(Object obj){
    	 //要获取类的信息  首先要获取类的类类型
    	  Class c=obj.getClass();//传递的是哪个子类的对象  c就是该子类的类类型
    	  System.out.println("类的名称:"+c.getName());
    	  /**
    	   * Method类，方法对象
    	   * 一个成员方法就是一个Method对象
    	   * * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
		 * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
    	   */
    	  
    	  Method[] mc=c.getMethods();//c.getDeclaredMethods();
    	  for(int i=0;i<mc.length;i++){
    		  //得到方法的返回值类型的类类型
    		  Class returnType=mc[i].getReturnType();
    		  System.out.print(returnType.getName()+" ");
    		  //得到方法的名称
    		  System.out.print(mc[i].getName()+"(");
    		  //获取参数类型----》得到的是参数列表的类型的类类型
    		 Class[] paramType=mc[i].getParameterTypes();
    		  for(Class class1:paramType){
    			  System.out.print(class1.getName()+",");
    		  }
    		  System.out.println(")");
    	  }
    	  
    	 
      }

三：通过反射获取成员变量的信息

  /**
       * 获取成员变量的信息
       * @param obj
       */
     public static void printFiledMessage(Object obj){
    	 Class c=obj.getClass();
    	 /**
    	  * 成员变量也是对象
    	  * java.lang.reflect.Field
    	  * Filed类封装了关于成员变量的操作
    	  * getFields()方法获取的是所有的public的成员变量的信息
    	  * getDeclareFields获取的是该类自己的成员变量的信息
    	  */
    	  //Field[] fs=c.getFields();
    	  Field[] fs=c.getDeclaredFields();
    	  for(Field field:fs){
    		  //得到成员变量的类型的类类型
    		 Class fieldType=field.getType();
    		 String typeName=fieldType.getName();
    		 //得到成员变量的名称
    		 String fieldName=field.getName();
    		 System.out.println(typeName+" "+fieldName);
    	  }
    	 
     }

四，通过反射获取构造函数的信息

 //获取构造函数的信息
     public static void printConmMessage(Object obj){
    	Class c=obj.getClass();
    	 /**
    	  * 构造函数也是对象
    	  * java.lang.Constructor中封装了构造函数的信息
    	  * getConstructors获取所有的public的构造函数
    	  * getDeclaredConstructors得到所有的构造函数
    	  */
    	 //Constructor[] cs=c.getConstructors();
    	 Constructor[] cs=c.getDeclaredConstructors();
    	 for(Constructor con:cs){
    		 System.out.print(con.getName()+"(");
    		 ////获取构造函数的参数列表--->得到的是参数列表的类类型
    		 Class[] paramType=con.getParameterTypes();
    		 for(Class class1:paramType){
    			 System.out.print(class1.getName()+",");
    		 }
    		 System.out.println(")");
    	 }
    	  
     }

五，通过JavaBean的属性获取属性值

 

 /**
      * 根据标准的Javabean对象的属性名获取器属性值
      * @param obj
      * @param propertyName
      * @return
      */
     public static Object getValueByPropertyName(Object obj,String propertyName){
    	 //根据属性名称可以获取器get方法
    	 String getMethodName="get"+propertyName.substring(0, 1).toUpperCase()
    			 +propertyName.substring(1);
    	  //获取方法对象
    	 Class c=obj.getClass();
    	 try {
			   //get方法都是public的且无参数
    		  Method m=c.getMethod(getMethodName);
    		   //通过方法的反射操作方法
    		 Object value=m.invoke(obj);
    		  return value;
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
    	 
    	 
     } 

javaBean对象：

public class User {
	private String username;
	private String userpass;
	private int age;
	public User(){}
	
	public User(String username, String userpass, int age) {
		super();
		this.username = username;
		this.userpass = userpass;
		this.age = age;
	}

	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getUserpass() {
		return userpass;
	}
	public void setUserpass(String userpass) {
		this.userpass = userpass;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	

}

六，通过反射了解集合泛型的本质

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);
		//反射的操作都是编译之后的操作
		
		/*
		 * 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);
			}*///现在不能这样遍历
		} catch (Exception e) {
		  e.printStackTrace();
		}
	}