本站消息

站长简介/公众号

出租广告位,需要合作请联系站长

飞向远方

577

文章

303926

访问

+关注

分类

暂无分类

日期归档

2024-11(1)

Java之反射基础详解

发布于2021-05-29 20:50 阅读(942) 评论(0) 点赞(20) 收藏(2)

一、反射

（一）反射概述

在这里插入图片描述

Java反射机制：是指在运行时去获取一个类的变量和方法信息。然后通过获取到的信息来创建对象，调用方法的一种机制。由于这种动态性，可以极大的增强程序的灵活性，程序不用在编译期就完成确定，在运行期仍然可以扩展

（二）获取Class类的对象

我们要想通过反射去使用一个类，首先我们要获取到该类的字节码文件对象，也就是类型为Class类型的对象
这里我们提供三种方式获取Class类型的对象
①、使用类的class属性来获取该类对应的Class对象。举例：Student.class将会返回Student类对应的Class对象
②、调用对象的getClass()方法，返回该对象所属类对应的Class对象
该方法是Object类中的方法，所有的Java对象都可以调用该方法
③、使用Class类中的静态方法forName(String className)，该方法需要传入字符串参数，该字符串参数的值是某个类的全路径，也就是完整包名的路径

class Student{
    //成员变量:一个私有，一个默认，一个公共
    private String name;
    int age;
    public String address;
    //构造方法：一个私有，一个默认，一个公共
    public Student() {
    }

    private Student(String name) {
        this.name = name;
    }

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

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
    //成员方法：一个私有，四个公共
    private void function(){
        System.out.println("function");
    }
    public void method1(){
        System.out.println("method");
    }
    public void method2(String s){
        System.out.println("method:"+s);
    }
    public String method3(String s,int i){
        return s +"," +i;
    }

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

//测试
public class ReflectDemo{
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象
        Class<Student> c1 = Student.class;
        System.out.println(c1);

        Class<Student> c2 = Student.class;
        System.out.println(c2==c1);//true
        System.out.println("---------");

        //调用对象的getClass()方法，返回该对象所属类对应的Class对象
        Student s = new Student();
        Class<? extends Student> c3 = s.getClass();
        System.out.println(c1==c3);//true

        //使用Class类中的静态方法forName(String className)
        Class<?> c4 = Class.forName("com.tao.Student");
        System.out.println(c1==c4);//true
    }
}

（三）反射获取构造方法并使用

Class类中用于获取构造方法的方法
①、Constructor<?>[] getConstructors()：返回所有公共构造方法对象的数组

public class ReflectDemo{
    public static void main(String[] args) throws ClassNotFoundException {
        //获取反射对象
        Class<?> c = Class.forName("com.tao.Student");

        //Constructor<?>[] getConstructors()返回一个包含Constructor对象的数组，
        //Constructor对象反映了由该Class对象表示的类的所有公共构造函数
        Constructor<?>[] cons = c.getConstructors();
        for (Constructor<?> con : cons) {
            System.out.println(con);
        }
    }
}

运行结果：
下面的构造方法都是公共的
public com.tao.Student(java.lang.String,int,java.lang.String)//有三个参数的构造
public com.tao.Student()//无参构造方法

②、Constructor<?>[] getDeclaredConstructors()：返回所有构造方法对象的数组

public class ReflectDemo{
    public static void main(String[] args) throws ClassNotFoundException {
        //获取反射对象
        Class<?> c = Class.forName("com.tao.Student");

        //Constructor<?>[] getDeclaredConstructors()返回反映由该Class对象表示的类声明的所有构造函数的Constructor对象的数组
        Constructor<?>[] cons = c.getDeclaredConstructors();
        for (Constructor<?> con : cons) {
            System.out.println(con);
        }
    }
}

运行结果：
public com.tao.Student(java.lang.String,int,java.lang.String)
com.tao.Student(java.lang.String,int)
private com.tao.Student(java.lang.String)
public com.tao.Student()

③、Constructor<T> getConstructor(Class<?>... parameterTypes)：返回单个公共构造方法对象
④、Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：返回单个构造方法对象
Constructor类中用于创建对象的方法：T newInstance(Object... initargs)：根据指定的构造方法创建对象

public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取反射对象
        Class<?> c = Class.forName("com.tao.Student");

        //参数：你要获取的构造方法的参数的个数和数据类型对应的字节码文件对象
        
        //Constructor<T> getConstructor (Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由该Class对象表示的类的指定的公共构造函数
        Constructor<?> con = c.getConstructor();//不填表示获取无参构造方法
        //Constructor提供了一个类的单个构造函数的信息和访问权限
        //T newInstance(Object... initargs)使用由此Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例
        Object obj = con.newInstance();//不填表示获取无参构造方法
        System.out.println(obj);//Student{name='null', age=0, address='null'}

        //Constructor<T> getDeclaredConstructor (Class<?>... parameterTypes) 返回一个Constructor对象，该对象反映由该Class对象表示的类或接口的指定的构造函数
        Constructor<?> con1 = c.getDeclaredConstructor();
        Object obj1 = con1.newInstance();
        System.out.println(obj1);//Student{name='null', age=0, address='null'}
    }
}

（四）反射获取构造方法并使用练习

练习1：通过反射实现如下操作
Student s = new Student(“林青霞”,30,“西安”);
System.out.println(s);
基本数据类型也可以通过.class得到对应的Class类型

public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.tao.Student");

        //public Student(String name,int age, String address)
        //Constructor<T> getConstructor(Class<?>... parameterType)
        Constructor<?> con = c.getConstructor(String.class, int.class, String.class);
        //基本数据类型也可以通过.class类型

        //T newInstance(Object... initargs)
        Object obj = con.newInstance("林青霞", 30, "西安");
        System.out.println(obj);//Student{name='林青霞', age=30, address='西安'}
    }
}

练习2：通过反射实现如下操作
Student s = new Student(“林青霞”);
System.out.println(s);
public void setAccessible(boolean flag)：值为true，取消访问检查

public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.tao.Student");

        //public Student(String name)
        //Constructor<T> getDeclaredConstructor(Class<?>... parameterType)
        Constructor<?> con = c.getDeclaredConstructor(String.class);

        //暴力反射
        //public void setAccessible(boolean flag):值为引true，去校访问检查
        con.setAccessible(true);//可以使用私有的构造方法创建对象
        
        Object obj = con.newInstance("林青霞");
        System.out.println(obj);//Student{name='林青霞', age=0, address='null'}
    }
}

（五）反射获取成员变量并使用

Class类中用于获取成员变量的方法
①、Field[] getFields()：返回所有公共成员变量对象的数组
②、Field[] getDeclaredFields()：返回所有成员变量对象的数组
③、Field getField(String name)：返回单个公共成员变量对象
④、Field getDeclaredField(String name)：返回单个成员变量对象
Field类中用于给成员变量赋值的方法
void set(Object obj, Object value)：给obj对象的成员变量赋值为value

//反射获取成员变量
public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.tao.Student");

        //Filed[] getFields()返回一个包含Field对象反映由该Class对象表示的类或接口的所有可访问的公共字段
        Field[] fields = c.getFields();
        for (Field field : fields) {
            System.out.println(field);//public java.lang.String com.tao.Student.address
        }

        System.out.println("----------------------------");
        //Field[] getDeclaredField()返回一个Field对象的数组,反映了由该Class对象表示的类或接口声明的所有字段
        Field[] declaredFields = c.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }

        System.out.println("----------------------------");
        //Field[] getField(String name)返回一个Field对象,该对象表示的类或接口的指定公共成员字段
        Field addressField = c.getField("address");

        //获取无参构造方法创建对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        //Field提供有关类或接口的单个字段的信息和动态访问

        //Field[] getDeclaredField(String name)返回一个Field对象,该对象表示的类或接口的指定声明字段
        //void set(Object obj,Object value)将指定的对象参数中由此Field对象表示的字段设置为指定的新值
        addressField.set(obj,"西安");//给obj的成员变量addressField赋值为西安

        System.out.println(obj);
    }
}

运行结果：

public java.lang.String com.tao.Student.address
----------------------------
private java.lang.String com.tao.Student.name
int com.tao.Student.age
public java.lang.String com.tao.Student.address
----------------------------
Student{name='null', age=0, address='西安'}

（六）反射获取成员变量并使用练习

练习：通过反射实现如下操作

Student s = new Student();
s.name = "林青霞";
s.age = 30;
s.address = "西安";
System.out.println(s);

public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.tao.Student");

        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);//Student{name='null', age=0, address='null'}

        //s.name="林青霞"
        Field nameField = c.getDeclaredField("name");
        nameField.setAccessible(true);//取消访问检查
        nameField.set(obj,"林青霞");
        System.out.println(obj);//Student{name='林青霞', age=0, address='null'}

        //s.age=30
        Field ageField = c.getDeclaredField("age");
        ageField.set(obj,30);
        System.out.println(obj);//Student{name='林青霞', age=30, address='null'}

        //s.address="西安"
        Field addressField = c.getDeclaredField("address");
        addressField.set(obj,"西安");
        System.out.println(obj);//Student{name='林青霞', age=30, address='西安'}
    }
}

（七）反射获取成员方法并使用

Class类中用于获取成员方法的方法
①、Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
②、Method[] getDeclaredMethods()：返回所有成员方法对象的数组，不包括继承的
③、Method getMethod(String name, Class<?>... parameterTypes) ：返回单个公共成员方法对象
④、Method getDeclaredMethod(String name, Class<?>... parameterTypes)：返回单个成员方法对象
Method类中用于调用成员方法的方法
Object invoke(Object obj, Object... args)：调用obj对象的成员方法，参数是args,返回值是Object类型

//反射获取成员方法并使用
public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.tao.Student");

        //Method[] getMethods()返回一个包含方法对象的数组,方法对象反映由该Class对象表示的类或接口的所有公共方法,包括由类或接口声明的对象以及从超类和超级接口继承的类

        Method[] methods = c.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("------------------------------");
        //Method[] getDeclaredMethods()返回一个包含方法对象的数组,方法对象反映由该Class对象表示的类或接口的所有声明方法,包括public、protected、default(package)访问和私有方法
        Method[] declaredMethods = c.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }

        System.out.println("-------------------------------");
        //Method getMethod(String name,Class<?>... parameterTypes)返回会一个方法对象,该对象反映由该CLass对象表示的类或接口的指定公共成员方法
        Method method = c.getMethod("method1");
        //获取无参构造方法对象
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();
        //通过对象调用方法
        //在类或接口上提供有关单一方法的信息和访问权限
        //Object invoke(Object obj,Object... args)在具有指定参数的指定对象上调用此方法对象表示的基础方法
        //Object:返回值类型
        //obj:调用方法的对象
        //args:方法需要的参数
        method.invoke(obj);

        
        //Method getDeclaredMethod(String name,Class<?>... parameterTypes)返回会一个方法对象,它反映此表示的类或接口的指定声明的方法Class对象
        Method declaredMethod = c.getDeclaredMethod("method3", String.class, int.class);
        System.out.println(declaredMethod);

    }
}

运行结果：

public java.lang.String com.tao.Student.toString()
public java.lang.String com.tao.Student.method3(java.lang.String,int)
public void com.tao.Student.method2(java.lang.String)
public void com.tao.Student.method1()
public final void java.lang.Object.wait() throws java.lang.InterruptedException
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public boolean java.lang.Object.equals(java.lang.Object)
public native int java.lang.Object.hashCode()
public final native java.lang.Class java.lang.Object.getClass()
public final native void java.lang.Object.notify()
public final native void java.lang.Object.notifyAll()
------------------------------
public java.lang.String com.tao.Student.toString()
private void com.tao.Student.function()
public java.lang.String com.tao.Student.method3(java.lang.String,int)
public void com.tao.Student.method2(java.lang.String)
public void com.tao.Student.method1()
-------------------------------
method
public void com.tao.Student.method1()
public java.lang.String com.tao.Student.method3(java.lang.String,int)

（八）反射获取成员方法并使用练习

练习：通过反射实现如下操作
Student s = new Student();
s.method1();
s.method2(“林青霞”);
String ss = s.method3(“林青霞”,30);
System.out.println(ss);
s.function();

public class ReflectDemo{
    public static void main(String[] args) throws Exception {
        //获取Class对象
        Class<?> c = Class.forName("com.tao.Student");

        //Student s = new Student();
        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        //s.method1()
        Method m1 = c.getMethod("method1");
        m1.invoke(obj);//method

        //s.method2
        Method m2 = c.getMethod("method2", String.class);
        m2.invoke(obj,"林青霞");//method:林青霞

        //String ss = s.method3("林青霞",30)'
        //System.out.println(ss)
        Method m3 = c.getMethod("method3", String.class, int.class);
        Object o = m3.invoke(obj, "林青霞", 30);
        System.out.println(o);//林青霞,30

        //s.function()
        Method m4 = c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);//function
    }
}

（九）反射练习

练习1：我有一个ArrayList集合，现在我想在这个集合中添加一个字符串数据，如何实现？

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

public class Demo {
    public static void main(String[] args) throws Exception {
        //创建集合
        ArrayList<Integer> array = new ArrayList<>();

        Class<? extends ArrayList> c = array.getClass();
        Method m = c.getMethod("add", Object.class);

        m.invoke(array,"hello");
        m.invoke(array,"world");
        m.invoke(array,"java");

        //反射可以越过泛型的检查，获取到原始的方法所需要的参数类型
        System.out.println(array);//[hello, world, java]
    }
}

练习2：通过配置文件运行类中的方法

className=com.tao.Student
methodName=study

import java.io.FileReader;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;

class Student{
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

class Teacher{
    public void teach(){
        System.out.println("用爱成就学生");
    }
}

public class Demo {
    public static void main(String[] args) throws Exception {
        /*
        在class.txt中配置我们要使用的类，以及类中的方法
        className=xxx
        methodName=xxx
        */

        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("qfnu\\class.txt");
        prop.load(fr);
        fr.close();

        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        //通过反射使用
        Class<?> c = Class.forName(className);

        Constructor<?> con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getMethod(className);
        m.invoke(obj);
    }
}