java反射基础操作

获取类对象

采用静态方法获取类对象

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

构建一个类

package javatest;


public class csdnClass {
    String name;
    String sex;
    String number;
    int age;
    double gpa;
    public void Introduction() {
        System.out.println("一名" + age + "岁的" + sex + "生正在作自我介绍" );
    }
    public void Study() {
        System.out.println("学号为" + number + "的" + name + "的学期绩点为" + gpa);
    }

    public csdnClass(String name, String sex, String number, int age, double gpa) {
        this.name = name;
        this.sex = sex;
        this.number = number;
        this.age = age;
        this.gpa = gpa;
    }
}

使用反射获取该类的名字、包名、父类和接口

package javatest;

import java.util.Arrays;

public class csdn1 {
    public static void main(String[] args) throws Exception {
        Class<?> csdn = Class.forName("javatest.csdnClass");
        System.out.println(csdn.getName()); // 获取类名
        System.out.println(csdn.getPackage()); // 获取包名
        System.out.println(csdn.getSuperclass().getName()); // 获取父类名
        Class<?>[] csdnarray = csdn.getInterfaces(); // 获取接口，以数组形式表示
        System.out.println(Arrays.toString(csdnarray)); // 返回字符串表现形式
    }
}

使用反射获取类的构造方法并实例化的对象

引用https://blog.csdn.net/stdio_54456153/article/details/99468742

getDeclaredConstructor()方法会根据他的参数对该类的构造函数进行搜索并返回对应的构造函数，没有参数就返回该类的无参构造函数，然后再通过newInstance进行实例化。Class.getDeclaredConstructor().newInstance() 更明确化，明确调用的是哪一个构造器，而不是直接采用默认的无参构造器了。

package javatest;

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

public class csdn2 {
    public static void main(String[] args) throws Exception{
        Class<?> csdn1 = Class.forName("javatest.csdnClass");
        // 获取构造方法Constructor
        Constructor<?>[] cos = csdn1.getConstructors();
        // 简便方法:类对象.newInstance()
        csdnClass student1 = (csdnClass) csdn1.getDeclaredConstructor().newInstance();
        // 获取有参构造方法
        csdnClass student2 = (csdnClass) csdn1.getDeclaredConstructor(String.class,String.class,String.class,int.class,double.class).newInstance("a","男","2018",17,3.64);
    }
}

使用反射获取类中的方法并进行调用

package javatest;



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

public class csdn3 {
    public static void main(String[] args) throws Exception {
        // 获取类对象
        Class csdn3 = Class.forName("javatest.csdnClass");
        // 1.获取方法Method对象,获取不到私有方法,即只能获取公开方法
        Method[] methods = csdn3.getMethods();
        // 2.getDeclaredMethods() 获取类中的所有方法
        Method[] methods1 = csdn3.getDeclaredMethods();
        // 3.获取特定的单个方法
        //3.1 getMethod(方法名，若有参数此处填写参数类型.class)
        Method Studymethod = csdn3.getMethod("Study");
        // 3.2 实例化对象
        csdnClass student3 = (csdnClass) csdn3.getDeclaredConstructor().newInstance();
        // 3.3 method.invoke(Object obj,args) 其中obj为调用该方法的实例化对象，args为方法的参数
        Studymethod.invoke(student3);
        // 4.获取私有方法，需要设置访问权限无效
        Method Privatemethod = csdn3.getDeclaredMethod("私有方法名");
        Privatemethod.setAccessible(true);
        // 5.获取静态方法
        Method Staticmethod = csdn3.getMethod("静态方法");
        Staticmethod.invoke(null,args);
    }
}

使用反射构造一个适用于任何对象的通用方法

构建一个返回值为Object的静态方法，该方法应包含四个参数
Object obj : 类名
String Methodname：要调用的方法名称
Class<?>[] types：被调用的方法名中所需要的参数，用数组形式来表示
args：给需要的参数赋值

使用反射获取类中的属性

package javatest;

import java.lang.reflect.Field;

public class csdn4 {
    public static void main(String[] args) throws Exception{
        // 获取类对象
        Class<?> csdn4 = Class.forName("javatest.csdnClass");
        // 获取公开的属性或字段，保存在数组中
        Field[] fields = csdn4.getDeclaredFields();
        // 获取单独的属性
        Field namefield = csdn4.getField("name");
        // 实例化对象
        csdnClass student4 = (csdnClass) csdn4.getDeclaredConstructor().newInstance();
        // 赋值
        namefield.set(student4,"abc");
    }

}