浅谈反射

1.如何得到类对象

 

   <1>类名.class
   <2>对象.getClass()
   <3>Class.forName("全限定名");
   <4>类加载的loadClass("全限定名")；
   <5>子类.class.getSuperClass();

 

   <6>包装类.class

2.根据类得到类名(全限定名)
c.getName()------------>全限定名
c.getSimpleName() ---->类名
c.getPackage()---------->包名

3.根据类得到类的属性
c.getField("field属性名");
属性名：f.getName()
属性修饰符：f.getModifiers()
属性的数据类型：f.getType().getName()
给属性设值：f.set()
得到属性的值：f.get()
得到私有的属性：f.getDeclaredField("属性名");
得到所有的声明的属性
c.getDeclaredFields()

4.根据类得到类的方法
c.getMethod()
c.getDeclaredMethod();

 

代码实例：

 

package com.zking.test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.junit.Test;

import com.zking.entity.Person;

public class TestRe {
	
	/**
	 * 获取实现该类的所有接口 及 父类
	 */
	@Test
	public void test6(){
		Class clazz=Person.class;
		System.out.println(clazz.getSuperclass().getSimpleName());
		//实现的接口
		Class clazzInterface[]=clazz.getInterfaces();
		for (Class c : clazzInterface) {
			System.out.println(c.getSimpleName());
		}
	}
	
	
	
	
	
	/**
	 * 获取该类所有的构造方法，并执行
	 */
	@Test
	public void test5(){
		Class clazz=Person.class;
		Constructor constructor[]=clazz.getDeclaredConstructors();
		for (Constructor c : constructor) {
			System.out.println(c.getModifiers());
			Class clazzType[]=c.getParameterTypes();
			for (Class cc : clazzType) {
				System.out.println(" "+cc.getSimpleName());
			}
		}
		//调用构造方法（使用构造方法进行实例化对象）
		try {
			//clazz.newInstance();//调用无参构造
			//调用有参构造
			Constructor constru=clazz.getDeclaredConstructor(Integer.class,String.class,Integer.class);
			constru.newInstance(1,"123",2);
		} catch (Exception e) {
			e.printStackTrace();
		} 
	}
	
	
	
	/**
	 * 根据类对象 获取 类的所有的方法
	 */
	@Test
	public void test4(){
		//获取所有的方法
		Class clazz=Person.class;
		Method methods[]=clazz.getDeclaredMethods();
		System.out.println(methods.length);
		for (Method method : methods) {
			//获取每个方法的名字
			System.out.println(method.getName());
			
			//每个方法的返回值类型
			System.out.println("  "+method.getReturnType().getName());
			
			//每个方法的修饰符
			System.out.println("  "+method.getModifiers());
			
			//获取每个方法的参数列表
			Class[] classType=method.getParameterTypes();
			for (Class c : classType) {
				System.out.println("   "+c.getSimpleName());
			}
		}
		
		
		//调用方法(无参数)
		try {
			Person person=new Person();
			Method method=clazz.getDeclaredMethod("sleep", String.class,String.class);
			//设置可访问
			method.setAccessible(true);
			//执行方法
			method.invoke(person, "aa","bb");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 根据类对象 获取 类的属性
	 */
	@Test
	public void test3(){
		try {
			
			//之前
			Person person=new Person();
			//person.setPid(1);
			Person person2=new Person();
			//person2.setPid(100);
			Class clazz=Person.class;
			Field[] fields=clazz.getFields();//只能获取public修饰的属性
			Field[] fields2=clazz.getDeclaredFields();//获取所有的属性（包括私有）
			for (Field field : fields2) {
				//获取所有属性的属性名
				System.out.println(field.getName());
			}
			
			System.out.println(fields2.length);
			//获取单个属性（获取的public）
			Field field=clazz.getField("pid");
			//给属性设值
			field.setInt(person, 100);
			//获取属性的值
			System.out.println(field.getInt(person));
			
			//获取单个属性(修饰符为private)
			//Field fieldPname=clazz.getField("pname");
			Field fieldPname=clazz.getDeclaredField("color");
			System.out.println(fieldPname);
			
			System.out.println("psex的数据类型为："+fieldPname.getType().getSimpleName());
			//private 2
			//public 1
			//protected 4
			//默认 0
			//static 8
			//final 16
			
			System.out.println(Modifier.isPublic(25));
			
			System.out.println("color的修饰符为："+fieldPname.getModifiers());
			
			//设置可以访问
			fieldPname.setAccessible(true);
			
			//给私有的属性设值
			fieldPname.set(person, "tt");
			
			//获取私有属性的值
			System.out.println(fieldPname.get(person));
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 根据类对象 获取 类名(全限定名  包名)
	 */
	@Test
	public void test2(){
		Class clazz=Person.class;
		//获取全限定名
		System.out.println(clazz.getName());
		//获取类名(不包括包名)
		System.out.println(clazz.getSimpleName());
		//获取包名
		System.out.println(clazz.getPackage().getName());
	}
	
	/**
	 * 获取类对象
	 */
	@Test
	public void test1() {
		try {
			// 1.实体类.class
			// Class clazz=Person.class;
			// 2.对象.getClass
			// Person person=new Person();
			// Class clazz=person.getClass();
			// 3.Class.forName()
			//Class clazz = Class.forName("com.zking.entity.Person");
			//4.通过类加载的loadClass
//			ClassLoader classLoader=Person.class.getClassLoader();
//			Class clazz =classLoader.loadClass("com.zking.entity.Person");
			//5.通过子类.class.getSuperClass()
//			Class clazz =Son.class.getSuperclass();
//			System.out.println(clazz);
			
//			[6].获取包装类的类对象
			Class clazz=Integer.class;
			System.out.println(clazz);
			
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
}