java反射实操案例

一、反射介绍：

Reflection(反射)可以在运行时获取一个类的所有信息，并且可以操作类的字段、方法和构造器等。

二、常用反射操作:

1、获取类对应的字节码对象（后缀为.class）：

（1）类对象.getClass()

说明：追根溯源，使用的是Object类的getClass()方法，因为所有类都继承Object类，所以下面的子类也可以使用getClass()方法。

Student s = new Student();
Class cla = s.getClass();

（2）类名.class

说明：此处调用的是该类的class属性，获取该类对应的Class字节码对象。

Class cla = Student.class;

（3）Class.forname("类的路径")

说明：使用java自带的Class类中的forName("类的路径")静态方法。

Class cla = Class.forName("类的路径");

总结：反射机制的设计是为了灵活获取类，进而得到类的对象

。第一种方法对象已经存在，此时反射的价值不大。

第二种方法导入类的包，依赖性过强，耦合度高，没导报错。

第三种方法比较常用，安全且性能好。

测试以上三种方法：

package reflectTest;
/**
 * @author:tengsen
 * @create: 2022-10-08 21:19
 * @Description:
 */
public class TestReflect {
    public static void main(String[] args) throws ClassNotFoundException {

        //通过Student类拿到字节码对象
        Class<?> cla1 = new Student().getClass();

        //通过类的class属性拿到字节码对象
        Class<?> cla2 = Student.class;

        //根据类的路径拿到字节码对象
        Class<?> cla3 = Class.forName("reflectTest.Student");

        System.out.println("cla1："+cla1);
        System.out.println("cla2："+cla2);
        System.out.println("cla3："+cla3);
    }
}

 运行测试结果：

 

2、获取了类的Class对象后，可通过该字节码对象获取该类的多种信息

 （1）测试用的学生类：

package reflectTest;

/**
 * @author:tengsen
 * @create: 2022-10-08 15:57
 * @Description:
 */
public class Student {
    private String id;
    private String name;
    public int age;
    public String gender;
    public double waterFee;
    public Student() {
    }

    public Student(String id, String name, int age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
        waterFee=0;
    }

    public void study(){
        System.out.println("学习ing");
    }

    public boolean rechargeWaterBill(double money){
        waterFee+=money;
        System.out.println("成功充值"+money+"元,水费余额："+waterFee+"元");
        return true;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public double getWaterFee() {
        return waterFee;
    }

    public void setWaterFee(double waterFee) {
        this.waterFee = waterFee;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", waterFee=" + waterFee +
                '}';
    }
}

 （2）得到类属性的方法：

1>字节码对象.getFields()。说明：得到公有属性。

2>字节码对象.getDeclareFields()。说明：得到所有属性，无论是公有还是私有。

测试代码：

package reflectTest;

import java.lang.reflect.Field;

/**
 * @author:tengsen
 * @create: 2022-10-08 21:38
 * @Description:
 */
public class TestReflect2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> cla = Class.forName("reflectTest.Student");

        //getFields()得到公有属性
        Field[] fields1 = cla.getFields();
        System.out.println("getFields()的效果：");
        for (Field field:fields1){
            System.out.println("属性名："+field.getName());
            System.out.println("属性类型："+field.getType());
            System.out.println();
        }
        
        System.out.println();
        
        //getDeclaredFields()得到所有属性，无论公有还是私有
        Field[] fields2 = cla.getDeclaredFields();
        System.out.println("getDeclareFields()的效果：");
        for(Field field:fields2){
            System.out.println("属性名："+field.getName());
            System.out.println("属性类型："+field.getType());
            System.out.println();
        }
    }
}

 ​​​​​​运行测试结果：

 

 （3）得到类方法的方法：

 字节码对象.getMethods()。说明：得到该字节码对象对应类的所有方法。

测试代码：

package reflectTest;

import java.lang.reflect.Method;
import java.util.Arrays;

/**
 * @author:tengsen
 * @create: 2022-10-09 12:07
 * @Description:
 */
public class TestReflect3 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> cla = Class.forName("reflectTest.Student");
        Method[] methods = cla.getMethods();//获取字节码对象对应类的所有方法，存于数组集合中
        for (Method method: methods){

            System.out.println("该方法对象详情为：");
            System.out.println(method);

            System.out.print("方法名为：");
            System.out.println(method.getName());

            Class<?>[] parameterTypes = method.getParameterTypes();//获取该方法的所有参数类型的数组集合
            System.out.print("该方法的参数类型的数组集合为：");
            System.out.println(Arrays.toString(parameterTypes));

            System.out.println();
        }
    }
}

 运行结果截图：

 （4）通过获取字节码，进而创建对象：

1>字节码对象.newInstance()。说明：执行无参构造创建对象。
2>字节码对象.newInstance(实参列表)。说明：执行有参构造创建对象。

测试代码：

package reflectTest;

import java.lang.reflect.Constructor;

/**
 * @author:tengsen
 * @create: 2022-10-09 14:47
 * @Description:
 */
public class TestReflect4 {
    public static void main(String[] args) throws Exception {
        Class<?> cla = Class.forName("reflectTest.Student");

        //如果已知构造器参数类型构成，可直接通过字节码对象获取对应构造器
        Constructor<?> cons = cla.getConstructor(String.class,String.class,int.class,String.class);

        //有参构造
        Student student1 = (Student) cons.newInstance("006","古草",21,"男");
        System.out.println(student1);

        //通过字节码对象，直接反射获取无参构造的类实例
        Student student2 = (Student) cla.newInstance();
        System.out.println(student2);
    }
}

  运行结果截图：

 （5）通过字节码对象获取包名、类名：

1>字节码对象.getPackage().getName()。说明：获取包名。
2>字节码对象.getName()。说明：获取完整类名。
3>字节码对象.getSimpleName()。说明：获取类名。

测试代码：

package reflectTest;

/**
 * @author:tengsen
 * @create: 2022-10-09 15:01
 * @Description:
 */
public class TestReflect5 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class cla = Class.forName("reflectTest.Student");

        //获取包名
        System.out.println("Student类的包名："+cla.getPackage());

        //获取完整类名
        System.out.println("Student类的完整类名："+cla.getName());

        //获取简洁类名
        System.out.println("Student类的简洁类名："+cla.getSimpleName());
    }
}

   运行结果截图：