《Java核心技术》反射部分阅读记录

能够分析类能力的程序称为反射

反射可以用来

  • 在运行的时候分析类的能力
  • 在运行的时候检查对象
  • 实现泛型数组操作代码
  • 利用Method对象

①Class类

Java运行时虚拟机始终为所有对象维护一个运行时类型标记，这个信息会跟踪每个对象所属的类

用一个叫做Class的特殊的类保存这些信息

  • Object类中的getClass()方法会返回一个Class类型的实例
Employee e;
Class cl = e.getClass();

Class对象描述一个特定类的属性，上面代码中的对象cl描述的就是Employee类的属性

  • Class类常用方法getName()

    返回class对象对应的类的名称

System.out.println(e.getClass().getName()+" "+e.getName());
//e是员工，输出"Employee Harry Hacker"
//e是经理，输出"Manager Harry Hacker"

  • forName()方法

    作用：加载指定类名的class对象

Class cl = Class.forName("Employee");

上例代码中，forName方法通过参数"Employee"指定了class对象cl描述的类是Employee类

注意：常与异常处理器配合使用

  • T.class快捷方式获得class对象
Class cl = int.class;

这里自动给cl匹配了class对象（根据int类型分配了Integer类）

虚拟机为每个类型管理一个唯一的class对象，因此可以使用==实现两个类对象的比较

if(e.getClass()==Employee.getClass()){
    ...
}

  • 获取类的构造方法

    使用getConstructor()方法获取当前class对象所指的类的构造方法

    再使用newInstance()创建一个所指的类的对象

Class cl = Employee.class;
Employee e = cl.getConstructor().newInstance();

上面代码用Employee类的无参构造方法构造了一个新的Employee对象

②异常处理

无法确定通过Class.forName方法指定的类一定存在

需要在方法名上增加一个throws子句来处理这个异常

public static void doSomethingWithClass(String name)
    throws ReflectiveOperationException
{
    Class cl = Class.forName(name);//可能name指定的类是不存在的
    ...
}

调用这个方法的任何方法也需要一个throws声明，包括main方法

③使用反射分析类的能力

通过java.lang.reflect包中的三个类Field,Method和Constructor来描述一个类的结构，配合Modifier类描述类、方法、字段的访问权限。通常在构造一个class对象之后通过getter方法来构造这三个类(返回值通常存放在数组里)

Class cl = Class.forName(name);
Field[] fields = cl.getDeclaredFields();
Method[] methods = cl.getDeclaredMethods();
Constructor[] constructors = cl.getDeclaredConstructors();
for(Field f:fields){
    String modifiers = Modifier.toString(f.getModifiers());//获取权限
}
...

下面代码的作用是输入一个类名，输出它的构造器、方法、字段

/**
 * @author whl
 * @date 2020/7/7 - 15:04
 */
import java.util.*;
import java.lang.reflect.*;

public class ReflectionTest {
    public static void main(String[] args) throws ReflectiveOperationException{
        String name;
        /**
         *可以在命令行运行这个类的时候加参数
         * 加了就存放在args数组里
         */
        if (args.length>0)
            name=args[0];
        else {
            Scanner in = new Scanner(System.in);
            System.out.println("Enter class name(e.g. java.util.Date):");
            name=in.next();
        }

        Class cl = Class.forName(name);
        Class supercl = cl.getSuperclass();//cl的父类
        String modifiers = Modifier.toString(cl.getModifiers());//cl的权限修饰符
        if (modifiers.length()>0)
            System.out.print(modifiers+" ");
        System.out.print("class "+name);
        if (supercl!=null && supercl!=Object.class)//父类不能是null，同时父类不能是object
            System.out.print(" extends "+supercl.getName());//显示cl继承于什么类

        System.out.print("\n{\n");
        printConstructors(cl);//输出构造器
        System.out.println();
        printMethods(cl);//输出方法
        System.out.println();
        printFields(cl);//输出成员
        System.out.println("}");
    }

    private static void printFields(Class cl) {
        /*
        * Field类用于描述一个类的成员
        * getDeclaredFields()方法返回这个类中定义的字段的数组
        * getFields()方法返回这个类及其父类定义的字段的数组
        * */
        Field[] fields = cl.getDeclaredFields();//构造一个存放Field对象的数组

        for (Field f : fields) {
            Class type = f.getType();//字段的类型
            String name = f.getName();//字段的名称
            System.out.print("    ");//行首缩进
            String modifiers = Modifier.toString(f.getModifiers());//字段的权限修饰符
            if (modifiers.length()>0)
                System.out.print(modifiers+" ");
            System.out.println(type.getName()+" "+name+";");
        }
    }

    private static void printMethods(Class cl) {
        /*
        * Method类用于描述一个类的方法
        * getDeclaredMethods()方法返回这个类中定义的方法的数组
        * getMethods()方法返回这个类及其父类定义的全部公共方法的数组
        * */
        Method[] methods = cl.getDeclaredMethods();

        for (Method m : methods) {
            Class retType = m.getReturnType();//方法的返回类型
            String name = m.getName();//方法名称

            System.out.print("    ");
            String modifiers = Modifier.toString(m.getModifiers());//方法的权限修饰符
            if (modifiers.length()>0)
                System.out.print(modifiers + " ");
            System.out.print(retType.getName()+" "+name+"(");

            /*
            用for循环输出方法的参数
            */
            Class[] paraType = m.getParameterTypes();
            for (int i = 0; i < paraType.length; i++) {
                if (i>0)
                    System.out.print(", ");
                System.out.print(paraType[i].getName());
            }
            System.out.println(");");
        }
    }

    private static void printConstructors(Class cl) {
        /*
         * Constructor类用于描述一个类的构造器
         * getDeclaredConstructors()方法返回这个类中全部构造器的数组
         * getConstructors()方法返回这个类所有公共构造器的数组
         * */
        Constructor[] constructors = cl.getDeclaredConstructors();

        for (Constructor c:constructors){
            String name = c.getName();//构造器的名称
            System.out.print("    ");
            String modifiers = Modifier.toString(c.getModifiers());//构造器的权限修饰符
            if (modifiers.length()>0)
                System.out.print(modifiers+" ");
            System.out.print(name+"(");

            //用for循环输出构造器的参数
            Class[] paraTypes = c.getParameterTypes();
            for (int i = 0; i < paraTypes.length; i++) {
                if (i>0)
                    System.out.print(", ");
                System.out.print(paraTypes[i].getName());
            }
            System.out.println(");");
        }
    }
}

例：输入java.util.Date，输出结果如下

public class java.util.Date
{
    public java.util.Date(int, int, int, int, int, int);
    public java.util.Date(java.lang.String);
    public java.util.Date();
    public java.util.Date(long);
    public java.util.Date(int, int, int);
    public java.util.Date(int, int, int, int, int);

    public boolean after(java.util.Date);
    public boolean before(java.util.Date);
    public boolean equals(java.lang.Object);
    public java.lang.String toString();
    public int hashCode();
    public java.lang.Object clone();
    public int compareTo(java.util.Date);
    public volatile int compareTo(java.lang.Object);
    private void readObject(java.io.ObjectInputStream);
    private void writeObject(java.io.ObjectOutputStream);
    private final sun.util.calendar.BaseCalendar$Date normalize(sun.util.calendar.BaseCalendar$Date);
    private final sun.util.calendar.BaseCalendar$Date normalize();
    public static long parse(java.lang.String);
    public static java.util.Date from(java.time.Instant);
    public long getTime();
    public void setTime(long);
    public int getDate();
    public static long UTC(int, int, int, int, int, int);
    private static final java.lang.StringBuilder convertToAbbr(java.lang.StringBuilder, java.lang.String);
    private final sun.util.calendar.BaseCalendar$Date getCalendarDate();
    private static final sun.util.calendar.BaseCalendar getCalendarSystem(int);
    private static final sun.util.calendar.BaseCalendar getCalendarSystem(sun.util.calendar.BaseCalendar$Date);
    private static final sun.util.calendar.BaseCalendar getCalendarSystem(long);
    public int getDay();
    public int getHours();
    private static final synchronized sun.util.calendar.BaseCalendar getJulianCalendar();
    static final long getMillisOf(java.util.Date);
    public int getMinutes();
    public int getMonth();
    public int getSeconds();
    private final long getTimeImpl();
    public int getTimezoneOffset();
    public int getYear();
    public void setDate(int);
    public void setHours(int);
    public void setMinutes(int);
    public void setMonth(int);
    public void setSeconds(int);
    public void setYear(int);
    public java.lang.String toGMTString();
    public java.time.Instant toInstant();
    public java.lang.String toLocaleString();

    private static final sun.util.calendar.BaseCalendar gcal;
    private static sun.util.calendar.BaseCalendar jcal;
    private transient long fastTime;
    private transient sun.util.calendar.BaseCalendar$Date cdate;
    private static int defaultCenturyStart;
    private static final long serialVersionUID;
    private static final [Ljava.lang.String; wtb;
    private static final [I ttb;
}

​

④使用反射在运行时分析对象

利用反射可以查看在编译时还不知道的对象字段

  • 利用Field类中的get方法来查看对象字段的值
  • 利用Field类中的set方法设置对象字段的值
  • 利用Field,Method,Constructor对象中的setAccessible方法覆盖Java的访问控制
Employee harry = new Employee("Harry Hacker",50000,10,1,1989);
Class cl = harry.getClass();
Field f = cl.getDeclaredField("name");//此时只是有一个field对象描述name字段
f.setAccessible();//由于name是私有字段，所以要使它可访问可修改
Object v = f.get(harry);//v是String对象，内容为"Harry Hacker"

⑤调用任意方法和构造器

  • 使用Method类中的invoke方法，调用包装在当前Method对象中的方法
Employee harry = new Employee(...);
Class cl = harry.getClass();
Method ml = cl.getMethod("getName");
String n = (String)ml.invoke(harry);//在employee对象harry中调用了method对象ml描述的方法

  • 也可以在调用invoke时指定参数类型

    getMethod("raiseSalary",double.class);//raiseSalary的参数是double型

    invoke方法的签名

    Object invoke(Object obj,Object... args)
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

友情链接更多精彩内容