Java基础——Java反射机制

Reflection(反射)是Java被视为动态语言的关键,反射机制允许程序在执行期借助于Reflection API取得任何类内部信息,并能直接操作任意对象的内部属性及方法

Java反射机制提供的功能
  在运行时判断任意一个对象所属的
  在运行时构造任意一个类的对象
  在运行时判断任意一个类所具有的成员变量和方法
  在运行时调用任意一个对象的成员变量和方法
  生成动态代理

反射相关的主要API:
  java.lang.Class:代表一个类  是反射的源头,
  java.lang.reflect.Method:代表类的方法
  java.lang.reflect.Field:代表类的成员变量
  java.lang.reflect.Constructor:代表类的构造方法

  注:创建类时,尽量保留一个空参的构造器

 

Class实例的过程:源文件经过编译(javac.exe)以后,得到一个或多个.class文件
.class文件经过运行(java.exe)以后,就需要进行类的加载(通过JVM的类加载器)
加载到内存中,每一个放入缓存中的.class文件就是一个Class实例


如何获取class的实例
  1)前提:若已知具体的类,通过类的class属性获取,该方法最为安全可靠,程序性能最高
    实例:Class clazz = String.class;
  2)前提:已知某个类的实例,调用该实例的getClass()方法获取Class对象
    实例:Class clazz = “www.atguigu.com”.getClass();
  3)前提:已知一个类的全类名,且该类在类路径下,可通过Class类的静态方法forName()获取,可能抛出ClassNotFoundException
    实例:Class clazz = Class.forName(“java.lang.String”);
  4)其他方式(不做要求)
    ClassLoader cl = this.getClass().getClassLoader();
    Class clazz4 = cl.loadClass(“类的全类名”);

创建运行时类的对象:调用Class对象的newInstance()方法,实际就是调用了类的空参构造器
  要 求:1)类必须有一个无参数的构造器。
     2)类的构造器的访问权限需要足够。

@Test
	public void test2() throws Exception{
		//----------获取class的实例-------------
		//*******1.已知具体的类,通过类的.class属性获取实例********
		Class clazz = Farmer.class;//为什么不能调用类的具体属性和方法
		//*******2.已知某个类的实例,调用该实例的getClass()方法获取Class对象********
		Farmer far = new Farmer();
		Class clazz = "far".getClass();
		//*******3.已知类的全类名,且该类在类路径下,可调用Class类的静态方法forName()********
		Class clazz = Class.forName("test.Farmer");
		//*******4.通过类加载器********
		ClassLoader cl = this.getClass().getClassLoader();
		Class clazz = cl.loadClass("test.Farmer");
		Object obj = clazz.newInstance();//调用缺省的构造函数(空参的构造器),返回一个该Class对象的一个实例
		
		//-------1.获取运行时类的属性-------
		Field field = clazz.getField("name");//获取运行时类的属性
		Field[] fields1 = clazz.getFields();	//返回此Class对象所表示的类及其父类(直接或间接)或接口的public的Field
		Field[] fields2 = clazz.getDeclaredFields();//返回此Class对象所表示的类或接口的全部Field
		
		System.out.println(field);//public java.lang.String test.Farmer.name

		for(Field i : fields1) {
			System.out.println(i);//public java.lang.String test.Farmer.name
		}						  //public int test.Person.life
	
		for(Field i : fields2) {	//private test.Person test.Farmer.adversary
			System.out.println(i);	//public java.lang.String test.Farmer.name
		}							//int test.Farmer.age
		System.out.println();
		
		//------2.获取运行时类的方法------
		Method method = clazz.getMethod("getAdversary");//返回运行时类的方法
		Method[] methods1 = clazz.getMethods();//返回此Class对象所表示的类及其父类或接口的public的Method
		Method[] methods2 = clazz.getDeclaredMethods();//返回此Class对象所表示的类或接口的全部Method
		
		System.out.println(method);//public test.Person test.Farmer.getAdversary()
		
		for(Method i : methods1) {
			System.out.println(i);
		}
		
		System.out.println();
		for(Method i : methods2) {
			System.out.println(i);
		}
	}

获取运行时类的属性
  1.public Field[] getFields()
    Class clazz = String.class;
    Field[] fields = clazz.getFields(); 返回此Class对象所表示的类及其(直接和间接)父类或接口的public的Field。
  2.public Field[] getDeclaredFields()
    Field[] fields = clazz.getDeclaredFields(); 返回此Class对象所表示的类或接口的全部Field。

  Field方法中:
    public int getModifiers() 以整数形式返回此Field的修饰符
      int i = f.getModifiers();
      String str = Modifier.toString(i);
    public Class<?> getType() 得到Field的属性类型
    public String getName() 返回Field的名称

 

使用反射可以取得:
  1.获取运行时类的方法
    public Method[] getDeclaredMethods() 返回此Class对象所表示的类或接口的全部方法
    public Method[] getMethods() 返回此Class对象所表示的类及其(直接和间接)父类或接口的public的方法

  Method类中:
    public Class<?> getReturnType()取得全部的返回值
    public Class<?>[] getParameterTypes()取得全部的参数
    public int getModifiers()取得修饰符
    public Class<?>[] getExceptionTypes()取得异常信息
    Annotation[] ann = m.getAnnotations();

  2.获取全部的构造器
    public Constructor<T>[] getConstructors() 返回此 Class 对象所表示的类的所有public构造方法。
    public Constructor<T>[] getDeclaredConstructors() 返回此 Class 对象表示的类声明的所有构造方法。

  Constructor类中:
    取得修饰符: public int getModifiers();
    取得方法名称: public String getName();
    取得参数的类型:public Class<?>[] getParameterTypes();


  3.获得实现的全部接口
    public Class<?>[] getInterfaces() 确定此对象所表示的类或接口实现的接口。

  4.获得所继承的父类
    public Class<? Super T> getSuperclass() 返回表示此 Class 所表示的实体(类、接口、基本类型)的父类的 Class。

  5.获得Annotation相关
    get Annotation(Class<T> annotationClass) getDeclaredAnnotations() 只有定义为RUNTIME的才能被反射获取到
  6.获得泛型相关
    获取父类泛型类型:Type type = clazz.getGenericSuperclass();
    泛型类型:ParameterizedType param = (ParameterizedType)type;
    获取实际的泛型类型参数数组:Type[] arg = param.getActualTypeArguments();
      (Class)arg[0].getName()

  7.获得类所在的包 Package getPackage()


通过反射调用类中的指定方法

	//调用运行时类中指定方法
	@Test
	public void test1() throws Exception {
		//调用运行时类中指定的方法, 设置此方法操作时所需要的参数类型
		Class clazz = Farmer.class;
		Method md = clazz.getDeclaredMethod("skills", int.class, int.class);//记得要写方法的参数类型
		md.setAccessible(true);//当方法为非public时,要写
		Farmer farmer = (Farmer)clazz.newInstance();
		//调用指定的方法:Object invoke(Object obj, Object ... obj)//记得除了实例还要写上调用的参数的值哦
		Object returnVal = md.invoke(farmer, 12, 100);//返回值为md中的的返回值	Hello,I`m skye
		
		
		System.out.println(returnVal);
		
	}

 

调用指定属性

	//调用运行时类中指定属性
	@Test
	public void test3() throws Exception {
		Class clazz = Farmer.class;
		
		//1.获取指定属性
		Field name = clazz.getDeclaredField("name");
		//由于属性权限修饰符的限制,为了保证可以给属性赋值,需要在操作前使得此属性可被操作
		name.setAccessible(true);
		//2.创建运行时类的对象
		Farmer farmer = (Farmer)clazz.newInstance();
		System.out.println(farmer);//Farmer [adversary=null, name=hello, age=10]
		//3.将运行时类的指定属性赋值
		name.set(farmer, "Skye");
		System.out.println(farmer);//Farmer [adversary=null, name=Skye, age=10]  name是修改了的
	}

  

调用指定构造器创建运行时类的对象

	//调用指定的构造器创建运行时类的对象
	@Test
	public void test4() throws Exception {
		String className = "test.Farmer";
		Class clazz = Class.forName(className);
		
		Constructor cons = clazz.getDeclaredConstructor(int.class, int.class, int.class, int.class);
		cons.setAccessible(true);
		Farmer farmer = (Farmer)cons.newInstance(10, 10, 101, 12);//Farmer 生命值:10, 攻击值:10, 防御值:101, 金币:12
		System.out.println(farmer);
	}

  

 

动态代理:动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。

Proxy :专门完成代理的操作类,是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces) 创建一个动态代理类所对应的Class对象
static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 直接创建一个动态代理对象

 

package test;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//动态代理
interface Subject {
	void action();
}

class RealSubject implements Subject{
	public void action() {
		System.out.println("我是被代理类");
	}
}

class MyInvocationHandler implements InvocationHandler{
	//实现接口被代理类的对象的声明
	Object obj;
	
	//1.给被代理类对象实例化。2.返回一个代理类的对象
	public Object blind(Object obj) {
	  this.obj = obj;
       //newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  直接创建一个动态代理对象
	  return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
	}
	
	//当通过代理类对象发起对重写方法的调用时,都会转换为对如下invoke()方法的调用
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
	//newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)  直接创建一个动态代理对象
		//method方法的返回值是returnVal
	  Object returnVal = method.invoke(obj, args);
	  return returnVal;
	}
}

public class TestProxy {
	public static void main(String[] args) {
		//1.被代理类对象
		RealSubject real = new RealSubject();
		//2.创建一个实现了InvocationHandler接口的类的对象
		MyInvocationHandler handler = new MyInvocationHandler();
		//3.调用blind方法,动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
		Object obj = handler.blind(real);
		Subject sub = (Subject)obj;//此时sub就是代理类对象
		sub.action();//转到对InvocationHandler接口的实现类的invoke方法的调用
	}
}

  

  

 




posted @ 2017-11-11 11:10  SkyeAngel  阅读(243)  评论(0编辑  收藏  举报