Java中的反射机制

来源：互联网发布：淘宝旺铺基础版模板编辑：程序博客网时间：2024/06/06 07:03

【Java语言的反射机制定义】：在运行状态中，对于任意一个类，都能够知道这类的所有属性和方法，对于任意一个对象，都能够调用它的属性和方法；这种动态加载获取信息以及动态调用对象方法的功能就称为Java语言的反射机制。

【Java反射机制的作用】：

（1）在和运行时判断一个对象所属的类；

（2）在运行时构造任意一个类的对象

（3)在运行时判断任意一个类所具有的成员变量（属性）和方法；

（4)在运行时调用任意一个对象的方法

（5）生成动态代理

【帮助理解】：

一．任何一个类都是Class的实例对象，这个实例对象有三种表示形式：

People people = new People();
（1） Class c1 = People.class;// 这句话实际上也在告诉我们任何一个类都有一个隐含的静态属性class

（2）   Class c2 = people.getClass();
        System.out.println(c1 == c2);//true    //说明一个类只能是CLass类的一个实例
           /** 官网c1 c2表示了People类的类类型；类也是对象，是Class类的实例对象，这个对象我们称为People类的类类型 */

（3） Class c3 = Class.forName("cn.hpu.qinfeng.People");

System.out.println(c2 == c3);//true

二。//各种数据类型以及void等等的类类型
  Class ca=int.class;
  Class cb=String.class;
  Class cc=void.class;

  System.out.println(ca.getName());
  System.out.println(cb.getName());
  System.out.println(cb.getSimpleName());//不带包名
  System.out.println(cc.getName());

三我们完全可以通过类的类类型创建该类的对象实例

People people1 = (People) c1.newInstance();// 需要有无参数的构造方法

四打印类的信息，包括类的成员函数，成员变量,构造函数

1. 要获取类的信息，首先要获取类的类类型

Class c = obj.getClass();// obj的是Object哪个子类的对象，c就是该子类的类类型

2.获取类的名称

c.getName()；

3.获取成员方法

/*
   * 一个【成员方法】就是一个Method对象
   * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
   * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
   */

public static void printMemberMethodMessage(Object obj) {

Class c = obj.getClass();// 传递的是Object哪个子类的对象，c就是该子类的类类型

     Method[] ms = c.getMethods();
  for (int i = 0; i < ms.length; i++) {
   // 得到方法的返回值类型的类类型
   Class returnType = ms[i].getReturnType();
   System.out.print(returnType.getName() + " ");
   // 得到方法的名称
   System.out.print(ms[i].getName() + "(");

   // 获取参数类型得到的是参数列表的类型的类类型
   Class[] paramTypes = ms[i].getParameterTypes();
   for (Class class1 : paramTypes) {
    System.out.print(class1.getName() + ",");
   }
         System.out.println(")");

}
}

4.获取成员变量

public static void printFieldMessage(Object obj) {
  /*
   * 【成员变量】也是对象
   * java.lang.reflect.Field
   * Field类封装了关于成员变量的操作
   * getFields()方法获取的是所有public修饰的成员变量的值
   */
  // 要获取类的信息，首先要获取类的类类型
  Class c = obj.getClass();// 传递的是Object哪个子类的对象，c就是该子类的类类型
  Field[] fs = c.getFields();
  for (Field field : fs) {
   // 得到成员变量类型的类类型
   Class fieldType = field.getType();
   System.out.print(fieldType.getName() + " ");
   // 得到成员变量的名字
   System.out.println(field.getName());
  }
}

5.获取构造函数

public static void printConMessage(Object obj) {
  /*
   * 【构造函数】
   * java.lang.reflect.Constructor中封装了关于构造函数的信息
   * getConstructors()方法获取所有public的构造函数
   * getDeclaredConstructors得到所有的构造函数
   */
  // 要获取类的信息，首先要获取类的类类型
  Class c = obj.getClass();
  Constructor[] cs=c.getDeclaredConstructors();
  for(Constructor constructor:cs) {
   //得到构造函数的名字
   System.out.print(constructor.getName()+"(");

   //获取构造函数的参数类型列表
   Class[] paramTypes=constructor.getParameterTypes();
   for(Class class1:paramTypes) {
    System.out.print(class1.getTypeName()+" ");
   }
   System.out.println(")");
  }
}

五。//方法的反射操作

public class MethodReflect {
public static void main(String[] args) {
  Method method1=new Method();
  Class c=method1.getClass();
  try {
   //c.getMethod("add", int.class,int.class);//这两个方法都可以
   java.lang.reflect.Method m=c.getMethod("add", new Class[] {int.class,int.class});

   //方法的反射操作
   //method1.add(3, 5);//这个不是反射操作
   //方法的反射操作是使用m对想来进行方法的调用
   //如果方法没有返回值则返回null,如果有返回值，则返回对应的返回值
   //Object obj=m.invoke(method1,new Object[]{3,5});
   Object obj=m.invoke(method1,3,5);



   System.out.println("=================================");
   java.lang.reflect.Method m2=c.getMethod("add", String.class,String.class);
   Object obj2=m2.invoke(method1,"A","B");

   System.out.println("==========================================");
    //java.lang.reflect.Method m3=c.getMethod("add",new Class[] {} );
        java.lang.reflect.Method m3=c.getMethod("add" );

   //Object obj3=m3.invoke(method1,new Object[] {});
        Object obj3=m3.invoke(method1);
  } catch (Exception e) {
   e.printStackTrace();
  }

}

}
class Method{
public void add() {
  System.out.println("ppppppppppp");
}
public void add(int a,int b) {
  System.out.println(a+b);
}
public void add(String a,String b) {
  System.out.println(a.toUpperCase()+b.toLowerCase());
}
}

六通过反射来了解泛型

public class KnowGenericByReflect {
public static void main(String[] args) {
  ArrayList list1=new ArrayList();
  list1.add(13);

  ArrayList<String> list2=new ArrayList<String>();
  list2.add("hello");//这个集合只能放String 类型的
  //list2.add(123);

  Class c1=list1.getClass();
  Class c2=list2.getClass();

  System.out.println(c1==c2);//true
  //说明编译之后集合的泛型是去泛型化的，
  //Java中的集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效了

  try {
   java.lang.reflect.Method m = c2.getMethod("add", Object.class);
   m.invoke(list2,20);//绕过编译操作就绕过了泛型
   System.out.println(list2.size());//2
   System.out.println(list2);//hello 20
   /*for(String string:list2) {
    System.out.println(string);//java.lang.ClassCastException:
   }*/
  } catch (Exception e1) {
   e1.printStackTrace();
  }
}
}

阅读全文

0 0