java反射机制的使用

一、反射是什么?

JAVA反射机制是在运行状态中,对于任意一个类,都能够获取这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取类信息以及动态调用对象内容就称为java语言的反射机制。

二、反射的作用

  • 在运行时判断任意一个对象所属的类;
  • 在运行时构造任意一个类的对象;
  • 在运行时判断任意一个类所具有的成员变量和方法;
  • 在运行时调用任意一个对象的方法;

三、反射的实现

我们知道,要使用一个类,就要先把它加载到虚拟机中,生成一个Class对象。这个class对象就保存了这个类的一切信息。
反射机制的实现,就是获取这个Class对象,通过Class对象去访问类、对象的元数据以及运行时的数据。

四、反射机制中使用的类

  • java.lang.Class; 类的对象代表一个类的所有
  • java.lang.reflect.Constructor; 类的对象代表构造函数
  • java.reflect.Filed; 类的对象代表属性
  • java.lang.Method; 类的对象代表方法
  • java.lang.Modifier; 类的对象代表修饰符

五、反射机制的使用

1、获取Class对象的三种方式
//方式一:引用保存内存地址中堆中的对象
Class class = Class.forName(className);
//方式二:java语言种任何一个java对象都有getclass方法
Class class = 对象名.getClass();
//方式三:java中每个类型都有class属性
Class class = 对象名.class;
2、通过class对象创建一个java象
Obiect obj = class.newInstance();
3、在运行时,获取自己的父类信息
Class<?> parentClass = class.getSuperClass();
String parentName = parentClass.getName();
//获取父类多个接口
Class[] ins = parentClass.getInterfaces();
for(Class in :ins){
	System.out.println(in.getName());
}
4、获取类的全部方法存于一个数组中
//返回声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法
Method[] ms = class.getDeclaredMethods();
//返回可被访问的公共方法 
Method[] ms = clazz.getMethods();
for(Method m : ms){
	//方法的返回值类型
	Class returnType = m.getReturnType();
	//得到类型的简写名称
	System.out.println(returnType.getSimpleName());
	//方法名
	System.out.println(m.getName());
	//按照声明顺序返回 Class 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型
	Class [] ParameterType = m.getParameterTypes();
}

反编译类的某个method方法

class  Test{
	public boolean login(String name,String pwd){
		if("z".equals(name)&&"123".equals(pwd)){
			return true;
		}
 		return false;
	}

	public void logout(){
		System.out.println("已退出");
	}
}

public static void main(String[] args) throws Exception 
    {
         //获取类
         Class c = Class.forName("Test");
         //获取某个特定的方法,通过方法名加形参列表
         Method login = c.getDeclaredMethod("login",String.class,String.class);
         //通过反射机制执行login方法
         Object o = c.newInstance();
         //调用o对象的m方法,传递两个参数将结果存放在reValue中
         Object reValue = login.invoke(o,"z","123");
         System.out.println(reValue);
    }
5、获取类的全部字段,存于一个数组中
// 取得本类已声明的所有字段,包括私有的、保护的
Field[] fields = clazz.getDeclaredFields();
// 取得本类中可访问的所有公共字段
Field[] fileds = clazz.getFields();
for(Field filed:fileds ){
	Class type = field.getType();
	//获取类型的第一种方式
	System.out.println(type.getName());
	//获取类型的第二种方式
    System.out.println(type.getSimpleName());
}

反射某个类具体的某个Field

public static void main(String[] args) throws Exception
     {
         //获取类
         Class c = Class.forName("User");
        //获取id属性
        Field idf = c.getDeclaredField("id");
        //获取某个特定的属性可以用来代替set..,get..
        Object o = c.newInstance();
        //打破封装,导致java属性不安全
        idf.setAccessible(true);
        idf.set(o,"001");
         System.out.println(idf.get(o));//001
     }
6、获取类的全部构造函数,存于一个数组中
Constructor[] cs = class.getDeclaredConstructors();
for(Constructor con : cs){
	//获取修饰符
    System.out.println(Modifier.toString(con.getModifiers()));
    //获取构造方法名
    System.out.println(c.getName());
    //构造方法的形式参数列表
    Class [] parameterTypes = con.getParameterTypes();
}

获取某个类的某个构造方法并创造一个对象

//写的一个实体
class Customer
 {
     String name;
     int age;
     Customer(String name,int age){
       this.name = name;
       this.age=age;
     }
     public String toString(){
       return "Customer["+name+","+age+"]";
     } 
 }

class Test
 {
     public static void main(String[] args) throws Exception 
     {
         //获取类
         Class clazz = Class.forName("Customer");
         //获取特定的构造方法
         Constructor con = clazz.getDeclaredConstructor(String.class,int.class);
         //创建对象
         Customer customer = (Customer)con.newInstance("zhangsan",90);
         System.out.println(customer);
     }
 }

六、反射机制的优缺点

优点:

  1. 增加程序的灵活性,避免将程序写死到代码里。
  2. 代码简洁,提高代码的复用率,外部调用方便。
  3. 对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法。

缺点:

  1. 性能问题
    使用反射基本上是一种解释操作,用于字段和方法接入时要远慢于直接代码。因此Java反射机制主要应用在对灵活性和扩展性要求很高的系统框架上,普通程序不建议使用。
    反射包括了一些动态类型,所以JVM无法对这些代码进行优化。因此,反射操作的效率要比那些非反射操作低得多。我们应该避免在经常被 执行的代码或对性能要求很高的程序中使用反射。
  2. 使用反射会模糊程序内部逻辑
    程序人员希望在源代码中看到程序的逻辑,反射等绕过了源代码的技术,因而会带来维护问题。反射代码比相应的直接代码更复杂。
  3. 安全限制
    使用反射技术要求程序必须在一个没有安全限制的环境中运行。如果一个程序必须在有安全限制的环境中运行,如Applet,那么这就是个问题了。
  4. 内部暴露
    由于反射允许代码执行一些在正常情况下不被允许的操作(比如访问私有的属性和方法),所以使用反射可能会导致意料之外的副作用--代码有功能上的错误,降低可移植性。反射代码破坏了抽象性,因此当平台发生改变的时候,代码的行为就有可能也随着变化。