Java语言进阶-反射

Java反射机制概述

反射被视为动态语言的关键,反射机制允许程序在执行期间借助反射API获得任何类的内部信息,并能直接操作任意对象的内部属性与方法。

加载完类后,在堆内存的方法区就产生了一个Class类型的对象(一个类只有一个class对象)。这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子就可以看到类的结构,所以,我们形象的称为:反射。

Java反射机制提供的功能
  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时判断任意一个类所具有的成员变量和方法
  • 在运行时获取泛型信息
  • 在运行时调用任意一个对象的成员变量和方法
  • 在运行时处理注解
  • 生成动态代理
主要反射API
  • java.lang.Class:代表一个类
  • java.lang.reflect.Method:代表类的方法
  • java.lang.reflect.Field:代表类的成员变量
  • java.lang.reflect.Constructor:代表类的构造器

比对使用Java反射与不使用Java反射的区别

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionTest {
    public static void main(String[] args) throws NoSuchMethodException,InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException,
            NoSuchFieldException, SecurityException {
        // 反射前使用person类
        // 1.创建Person类的对象(这里只能new权限为公开的构造器,不能new权限为私有的构造器)
        Person p1 = new Person("张三",12);

        // 2.通过对象,调用其内部的属性、方法
        p1.age = 10;
        System.out.println(p1.toString());

        p1.show();

        // 在Person类外部,不能调用类内部的私有结构,比如name属性,showNation方法以及私有的构造器


        // 反射之后,对于Person类的操作
        Class clazz = Person.class;

        // 1.通过反射,创建Person类的对象
        Constructor cons =  clazz.getConstructor(String.class,int.class);
        // obj = person
        Object obj =  cons.newInstance("Tom",12);
        System.out.println(obj.toString());

        // 2.通过反射,调用对象指定的属性、方法
        // 属性
        Field age =  clazz.getDeclaredField("age");
        age.set(obj,10);
        System.out.println(obj.toString());
        
        // 方法 
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(obj);

        // 3.通过反射,调用对象指定的私有结构
        Constructor cons1 = clazz.getDeclaredConstructor(String.class);
        cons1.setAccessible(true);
        // 私有构造器
        Person p2 = (Person) cons1.newInstance("Jerry");
        System.out.println(p2); 
        
        // 私有属性
        Field name =  clazz.getDeclaredField("name");
        name.setAccessible(true);
        name.set(p2,"HanMeimei");
        System.out.println(p2.toString());

        // 私有方法
        Method showNation = clazz.getDeclaredMethod("showNation",String.class);
        showNation.setAccessible(true);
        showNation.invoke(p2,"中国");
    }
}

----------
public class Person {
    private String name;
    int age;

    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 Person() {
    }
    
    private Person(String name) {
        this.name = name;
    }
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }
    
    public void show(){
        System.out.println("你好,我是"+name);
    }

    private String showNation(String nation){
        System.out.println("我的国籍是"+nation);
        return nation;
    }
}

关于java.lang.class类

  1. 程序经过javac.exe命令后,会生成一个class结尾的字节码文件。接着我们使用java.exe命令将字节码文件加载到内存中。被加载到内存中的类被称为运行时类,此时的运行时类就是class的一个实例。
  2. 一言概之:class类的实例是运行时类,运行时类可以调用class类的属性,方法,构造器。

获取class类的实例除了运行时类,还有其他四种方法:

public class ReflectionTest1 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 已知具体的类
        Class clazz = String.class;

        // 已知类具体的实例
        Class clazz1 = "abc".getClass();

        // 已知一个类的全类名,且该类在类路径下
        Class clazz2 = Class.forName("java.lang.string");

        // 其他方式
        ClassLoader cl = "abc".getClass().getClassLoader();
        Class clazz3 = cl.loadClass("abc");
    }
}

哪些类型可以使用Class类呢?
  • class: 外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类

  • interface:接口

  • []:数组(只要元素类型与维度一样,容量差距再大也是同一个Class)

  • enum:枚举

  • annotation:注解@interface

  • primitive type:基本数据类型

  • void

类的加载与ClassLoader

类在被加载到内存中,会经过三个过程:

  1. 类的加载:将类的class文件读入内存,并为之创建一个java.lang.Class对象。此过程由类加载器完成。

    • 将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口(即引用地址)。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
  2. 类的链接:将类的二进制数据合并到JRE中

    • 将Java类的二进制代码合并到JVM的运行状态之中的过程。

      • 验证:确保加载的类信息符合JVM规范,例如:以cafe开头,没有安全方面的问题

      • 准备:正式为类变量(static)分配内存并设置类变量默认初始值的阶段,这些内存都将在方法区中进行分配。

      • 解析:虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。

  3. 类的初始化:JVM负责对类进行初始化

    • 执行类构造器()方法的过程。类构造器()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。(类构造器是构造类信息的,不是构造该类对象的构器)。

    • 当初始化一个类的时候,如果发现其父类还没有进行初始化,则需要先触发其父类的初始化。

    • 虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。

类的加载和链接都是在加载过程中完成的,但是类的初始化有的在加载过程中进行,有的在运行过程中进行。

了解类的初始化

类的初始化分为两种,主动初始化与被动初始化。

主动引用:

  • 当虚拟机启动,先初始化main方法所在的类

  • new一个类的对象

  • 调用类的静态成员(除了final常量)和静态方法

  • 使用java.lang.reflect包的方法对类进行反射调用

  • 当初始化一个类,如果其父类没有被初始化,则先会初始化它的父类

被动引用:

  • 当访问一个静态域时,只有真正声明这个域的类才会被初始化;当通过子类引用父类的静态变量,不会导致子类初始化

  • 通过数组定义类引用,不会触发此类的初始化

  • 引用常量不会触发此类的初始化(常量在链接阶段就存入调用类的常量池中了)

public class ClassLoadingTest {
    public static void main(String[] args) throws ClassNotFoundException {
        // 主动引用:一定会导致A和Father的初始化
        A a = new A();
        System.out.println(A.m);
        Class.forName("A");

        // 被动引用,不会导致A和Father的初始化
        A[] array = new A[5];

        //只会初始化Father
        System.out.println(A.b);
        
        //不会导致A和Father的初始化
        System.out.println(A.M);
    }
    static {
        System.out.println("main所在的类");
    }
    
}

class Father {
    static int b = 2;
    static {
        System.out.println("父类被加载");
    }
}

class A extends Father {
    static {
        System.out.println("子类被加载");
        m = 300;
    }
    static int m = 100;
    static final int M = 1;
}
了解类加载器
  • 类加载的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口。

  • 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。不过JVM垃圾回收机制可以回收这些Class对象。

了解ClassLoader

ClassLoader分为四类:

  • 引导类加载器(Bootstap Classloader):用C++编写的,是JVM自带的类加载器,负责Java平台核心库,用来装载核心类库。该加载器无法直接获取

  • 扩展类加载器(Extension Classloader):负责jre/lib/ext目录下的jar包或 –D java.ext.dirs 指定目录下的jar包装入工作库

  • 系统类加载器(System Classloader):负责java –classpath 或 –D java.class.path所指的目录下的类与jar包装入工作 ,是最常用的加载器

  • 自定义类加载器

//1.获取一个系统类加载器
ClassLoader classloader = ClassLoader.getSystemClassLoader();
System.out.println(classloader);

//2.获取系统类加载器的父类加载器,即扩展类加载器
classloader = classloader.getParent();
System.out.println(classloader);

//3.获取扩展类加载器的父类加载器,即引导类加载器
classloader = classloader.getParent();
System.out.println(classloader);

//4.测试当前类由哪个类加载器进行加载
classloader = Class.forName("exer2.ClassloaderDemo").getClassLoader();
System.out.println(classloader);

//5.测试JDK提供的Object类由哪个类加载器加载
classloader = Class.forName("java.lang.Object").getClassLoader();
System.out.println(classloader);

//*6.关于类加载器的一个主要方法:getResourceAsStream(String str):获取类路径下的指定文件的输入流
InputStream in = null;
in = this.getClass().getClassLoader().getResourceAsStream("exer2\\test.properties");
System.out.println(in);

获取运行时类的属性结构

获取运行时类的属性
import java.lang.reflect.Field;

public class FieldTest {
    public static void main(String[] args) {
        Class clazz = Person.class;
        // 获取属性结构
        // getFields 获取运行时类与其父类中声明为public的属性
        Field[] fields = clazz.getFields();
        for(Field f : fields){
            System.out.println(f);
        } 

        // getDeclaredFields 获取运行时类的全部属性
        Field[] fields1 = clazz.getDeclaredFields();
        for(Field f : fields1){
            System.out.print(f+"\t");

            // 返回权限修饰符
            int modifiers = f.getModifiers();
            System.out.print(modifiers+"\t");

            // 返回数据类型
            Class type = f.getType();
            System.out.print(type+"\t");

            // 返回变量名
            String fName = f.getName();
            System.out.println(fName);
        }
    }
}
获取运行时类的方法
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;

public class FieldTest {
    public static void main(String[] args) {
        Class clazz = Person.class;
        // 获取方法结构
        // getMethods 获取运行时类与其父类中声明为public的方法
        Method[] methods = clazz.getMethods();
        for(Method m : methods){
            System.out.println(m);
        } 

        // getDeclaredMethods 获取运行时类的全部方法
        Method[] methods1 = clazz.getDeclaredMethods();
        for(Method m : methods1){
            System.out.print(m+"\t");

            // 返回方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for(Annotation a:annos){
                System.out.print(a+"\t");
            }

            // 返回权限修饰符
            int modifiers = m.getModifiers();
            System.out.print(modifiers+"\t");

            // 返回方法返回值类型
            Class type = m.getReturnType();
            System.out.print(type+"\t");

            // 返回方法名
            String mName = m.getName();
            System.out.print(mName+"\t");
        
            // 返回形参列表
            System.out.print("(");
            Class[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                for(Class p : parameterTypes){
                    System.out.print(p.getName()+" ");
                }
            }
            System.out.print(")"+"\t");
            
            // 返回抛出的异常      
            System.out.print("<");
            Class[] exceptionTypes = m.getExceptionTypes();
            if(!(exceptionTypes == null && exceptionTypes.length == 0)){
                for(Class e : exceptionTypes){
                    System.out.print(e.getName()+" ");
                }
            }
            System.out.print(">"+"\t");
        
        }
    }
}
获取运行时类的构造器
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class FieldTest {
    public static void main(String[] args) {
        Class clazz = Person.class;
        // 构造器
        // getConstructors 获取当前运行时类中声明为public的构造器
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c : constructors){
            System.out.println(c);
        }

        // getDeclaredConstructors 获取当前运行时类中所有的构造器
        Constructor[] getDeclaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : getDeclaredConstructors){
            System.out.println(c);
        }
    }
}
相关推荐
©️2020 CSDN 皮肤主题: 技术黑板 设计师:CSDN官方博客 返回首页