反射总结笔记

反射

反射本质—动态获取类结构、动态调用类成员

反射缺点—慢

一、创建class对象三种方式

方法一

//先创建对象后调用getClass()方法
Object str =new Object();
Class c=str.getClass();//返回Class类型

方法二

//如果对象存在，可以直接使用.class
Class c=Object.class;

方法三

try{
    //无需考虑对象是否存在，直接获取，如果出错会抛出异常的
   Class c=Class.forName("java.lang.Objecet"); 
}catch(ClassNotFoundException e){
    e.printStackTrace();
}

二、反射获取构造方法

Constructor构造方法类

包：java.lang.reflect.Constructor

1.Constructor构造方法

Class c=Class.forName("类名");




//获取公有的，返回数组,有s
Constructor cons[]=c.getConstructors();

//获取指定公有构造方法
Constructor cons=c.getConstructor(int.class);//指定为int类型的参数，可以是其他类型的






//获取所有构造方法,包括私有，有s
Constructor cons[]=c.getDeclaredConstructors();

//获取指定构造方法
Constructor cons=c.getDeclaredConstructor(int.class);//指定为int类型的参数，可以是其他类型的
cons.setAccessible(true);//获取操作权限
Object obj=cons.newInstance(123);//如果有参数记得传参

2.得到Constructor对象

Object obj=cons.newInstance();

//参数可以传很多，多个参数,号隔开就可以，也可以传数组
Object parameters[]={"","",""};
Object obj=(Object)cons.newInstance(parameters);

3.Constructor可以调用的方法

getModifiers()–构造方法的修饰符
getName()–构造方法的名字
getParameterTypes()–构造方法参数类型–返回数组类型是Class

Class paras[]=con.getParameterTypes();

通过构造方法创建对象

//就是获取指定构造方法 c.getDeclaredConstructor(…);

1.无参

//获取无参构造方法，注意和上面的获取所有构造方法区别开，这里没有s
Constructor cons=c.getDeclaredConstructor();
Object obj=cons.newInstance();
System.out.println(obj.toString());

2.有参

//获取有参
Constructor cons=c.getDeclaredConstructor(int.class);
Object obj=cons.newInstance(123);



//如果构造方法是私有的，可以设置setAccessible获取
Constructor cons=c.getDeclaredConstructor(int.class,String.class,double.class);
cons.setAccessible(true);//获取操作权限
Object obj=cons.newInstance(-1,"反射",-1.1);

三、反射获取成员变量

Field成员变量类

包：java.lang.reflect.Field

1.成员变量获取

Class c=Class.forName("类名");



//获取所有公有成员变量
Field fs[]=c.getFields();

//获取指定的公有成员变量
Field fs=c.getField(成员变量类型 成员变量名);



//获取所有成员变量
Field fs[]=c.getDeclaredFields();

//获取指定成员变量
Field fs=c.getDeclaredField(成员变量类型 成员变量名);    

2.调用方法

getModifiers()–成员变量的修饰符
getName()–成员变量的名字
getType()–成员变量的声明类型

3.获取属性，这里暂时省略了实体类

Class c=Class.forName("类名");
Field fs[]=c.getDeclaredFields();
for(Field f: fs){
    System.out.println(f.getModifiers());
    System.out.println(f.getType().getSimpleName());
    System.out.println(f.getName());
}

4.获取属性值，这里暂时省略了实体类

Class c=Class.forName("类名");

//首先获取Constructor得到构造函数，以及对象（这里对象为Example）
Constructor con =c.getConstructor();
Example e=(Example) con.newInstance();

//获取:通过获取所有成员变量，然后将获取到的getName(对象)
Field f=c.getDeclaredField("id");
f.setAcceessible(true);//如果是私有的要设置为true
f.set(e,3.14);//我们也可以修改属性值   .set(对象，修改后值)//f是id的即这里修改id值为3.14
System.out.println(f.getName(e));

5.获取和修改成员变量的值

四、反射获取成员方法

包：java.lang.reflect.Method

1.获取成员方法

Class c=Class.forName("类名");


//获取所有公有成员方法
Method ms[]=c.getMethods();

//获取指定公有成员方法
Method ms=c.getMethod(方法类型 方法名，int.class之类的);




//获取所有成员方法
Method ms[]=c.getDeclaredMethods();

//获取指定成员方法
Method ms=c.getDeclaredMethod(方法类型 方法名，int.class之类的);

2.调用成员方法

//invoke(调用方法的对象,方法参数)



Class c=Class.forName("类名");
//得到对象
Constructor con=c.getConstructor();
Object obj=con.newInstance();


//使用invoke方法调用成员方法，得到方法
//无参
Method ms=c.getDeclaredMethod("add");
ms.invoke(obj);//obj是要返回的对象


//有参
Method ms=c.getDeclaredMethod("调用的方法名",int.class,int.class);
ms.setAccessible(true);//如果私有的要获取权限
ms.invoke(obj,1,2);//obj是要返回的对象

3.方法

getModifiers()–成员方法的修饰符
getName()–成员方法的名字
getType()–成员方法的声明类型
getParameterTypes()–成员方法的参数数组

Class c=Class.forName("java.lang.String");
Method ms[]=c.getDeclaredMethods();
for(Mehtod m:ms){
    System.out.println(Modifier.toString(m.getModifiers()));//成员方法的修饰符
    System.out.println(m.getName());//成员方法的名字
    System.out.println(getReturnType().getSimpleName());//返回值
    
    //成员方法的参数数组
    Class paras[]=m.getParameterTypes();
    for(int i=0:i<paras.length;i++){
        System.out.println(paras[i].getSimpleName());
        if(i<paras.length-1){
            System.out.print(",");//除最后一个，其他加,拼接
        }
    }
}

补充：invoke()方法：
第一个参数是Object类型，也就是调用该方法的对象
第二个参数是一个可变参数类型，可以传参数：<1>多个参数 <2>数组参数