Java学习总结（十四）——java反射机制，利用反射动态创建对象

Posted 2020-10-31

一．Java反射机制
1.什么是反射：反射就是把Java类中的各种成份影射成一个个的Java对象。例：一个类有：成员变量，方法，构造方法等，包等等信息，利用反射技术可以对一个类进行剖析，把各个组成部分影射成一个个对象。
2.Java反射常用类：
（1）Class类—可获取类和类的成员信息
（2）Field类—可访问类的属性
（3）Method—可调用类的方法
（4）Constructor—可调用类的构造方法
3.如何使用反射（基本步骤）：
（1）导入java.lang.reflect.*
（2）获得需要操作的类的Java.lang.Class对象
（3）调用Class的方法获取Field,Method等对象
（4）使用反射API进行操作（设置属性，调用方法）
4.Class类：
（1）Class类是Java反射机制的起源和入口
（2）Class类的实例化对象代表一个正在运行的Java类或接口
·每个类都有自己的Class对象
·用于获取与类相关的各种信息
·提供了获取类信息的相关方法
·Class类继承至Object类
（3）Class类存放类的结构信息
·类名；·父类，接口；·方法，构造方法，属性；·注释
5.获取Class类对象的三种方式：
（1）方法一：
//方法1：对象.getClass()
Student stu=new Student();
Class clazz=stu.getClass();
（2）方法二：
//方法2：类.class
Class clazz= Student.class;
Class clazz=String.class;
方法三：
//方法3：Class.forName()
clazz=Class.forName("java.lang.String");
clazz=Class.forName("java.util.Date");
例（代码）：
学生信息类（bean）
package org.reflect.Class;

public class Student {
private String name;
private int age;
private double score;

public Student() {
}

public Student(String name, int age, double score) {
    this.name = name;
    this.age = age;
    this.score = score;
}

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 double getScore() {
    return score;
}

public void setScore(double score) {
    this.score = score;
}

public void learn() {
System.out.println(this.name + "正在学习...");br/>}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score

• "]";
  }

}

获取Class类对象测试类
package org.reflect.Class;

import java.lang.reflect.Modifier;
public class ClassDemo {

public static void main(String[] args) {
    Student stu=new Student();
    Class<?> c1=stu.getClass();//方式一
    Class<Student> c2= Student.class;//方式二
    Class<?> c3=null;
    try {
        c3=Class.forName("org.reflect.Class.Student");   // 方式三
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.out.println("方式一获取的Class对象为："+c1.getSimpleName());
    System.out.println("方式二获取的Class对象为："+c2);
    System.out.println("方式三获取的Class对象为："+c3);
    int mod=c1.getModifiers();//获取修饰符所对应的整数
    String modifier=Modifier.toString(mod);//获取修饰符
    System.out.println(c1+"类所用的修饰符为："+modifier);
}

}

运行结果：
方式一获取Class类对象：Student
方式二获取Class类对象：reflect.Student
方式三获取Class类对象：reflect.Student
Student类的修饰符：public
6.使用Class类获取类的结构信息
（1）获取类的Class对象：

（2）获取Filed对象

（3）获取Method对象

（4）获取Constructor对象

代码示例（示例均已上述Student类为基础）
例1（获取Filed对象）
package org.reflect.Filed;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class FiledDemo {

public static void main(String[] args) {
    Class<Student> cl=Student.class;//获取代表Student类的Class对象
    Field[] fields=cl.getDeclaredFields();//获取属性对象，返回数组
    System.out.println(cl.getSimpleName()+"类中声明的属性有：");
    for(Field f:fields){
        String filedName=f.getName();//获取属性名
        Class<?> filedType=f.getType();//获取属性类型
        int mod=f.getModifiers();//获取修饰符对应整数
        String modifier=Modifier.toString(mod);//获取修饰符
        System.out.println(modifier+" "+filedType.getSimpleName()+" "+filedName);
    }
}

}

运行结果：
Student类中声明的属性有：
private String name
private int age
private double score
例2（获取Method对象）
package method;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class MethodDemo {

public static void main(String[] args) {
    try {
        Class<?> cls=Class.forName("method.Student");
        Method[] methods=cls.getDeclaredMethods();
        for(Method method:methods){
            String methodName=method.getName();   // 获取方法名称
            Class<?> returnType=method.getReturnType();  // 获取方法的返回值类型
            String modStr=Modifier.toString(method.getModifiers());   // 获取方法的修饰符
            Class<?>[] paramTypes=method.getParameterTypes();   // 获取参数类型
            System.out.print(modStr+" "+returnType.getSimpleName()+" "+methodName+"(");
            if(paramTypes.length==0){
                System.out.print(")");
            }
            for(int i=0;i<paramTypes.length;i++){   // 遍历形式参数类型
                if(i==paramTypes.length-1){
                    System.out.print(paramTypes[i].getSimpleName()+" args"+i+")");
                }else{
                    System.out.print(paramTypes[i].getSimpleName()+" args"+i+",");
                }
            }
            System.out.println();
        }
    } catch (Exception e) {
        e.printStackTrace();
    }

}

}

运行结果：
public void eat(String args0,String args1)
public int getAge()
public void setAge(int args0)
public double getScore()
public void setScore(double args0)

7.使用反射动态创建对象
（1）方法一：
使用Class的newInstance()方法，仅适用于无参构造方法

（2）方法二：
方法二：调用Constructor的newInstance()方法，适用所有构造方法

例3（获取Constructor对象）
package org.reflect.Constructor;

import java.lang.reflect.Constructor;

public class ConstructorDemo {

public static void main(String[] args) {
    Class<Student> cl=Student.class;//获取Class对象，代表Student类
    try {
        Constructor<Student> con=cl.getDeclaredConstructor(String.class,int.class,double.class);//获取散参构造方法
        Student stu=con.newInstance("张无忌",23,96.7);
        System.out.println(stu);
    } catch (Exception e) {
        e.printStackTrace();
    } 
}

}
运行结果：
Student [name=张无忌, age=23, score=96.7]
例4（动态创建方法）：
package method;

import java.lang.reflect.Method;

public class InvokeMethod {

public static void main(String[] args) {
    Class<Student> cls=Student.class;
    try {
        Student stu=cls.newInstance();   // 通过反射机制实例化对象,使用此newInstance()方法，要求类中必须包含一个无参构造方法
        Method setNameMethod=cls.getMethod("setName",String.class);
        setNameMethod.invoke(stu,"风清扬");   // 使用stu对象调用setName(String name)方法，传入"风清扬"参数
        Method getNameMethod=cls.getMethod("getName");
        System.out.println(getNameMethod.invoke(stu));  // 使用stu对象调用getName()方法，返回一个值
    } catch (Exception e) {
        e.printStackTrace();
    } 

}

}
运行结果：
风清扬