Java：反射Reflection

反射

反射机制令Java拥有动态语言的特性

静态语言和动态语言

动态语言

在运行时能改变结构的语言：如新的函数、对象、代码可以被引进，已有的函数可以被删除或是其他结构上的变化。（在运行时代码可以根据某些条件改变自身结构）
主要动态语言：Object-C、C#、JavaScript、PHP、Python等

静态语言

运行时结构不可变的语言
主要静态语言：Java、C、C++
Java可以称为“准动态语言”，即拥有一定的动态性，可以利用反射机制获得类似动态语言的特性，让编程更加灵活，同时增加了不安全性

Reflection反射概述

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

Class class = Class.forName("全路径类名")

类在加载后，堆内存的方法区中产生了一个Class类型的对象，这个对象包含了类的完整结构信息
反射通过生成的对象获得类的结构和内容
通过Class类用于管理反射

反射的功能

在运行时判断对象的所属类
在运行时构造任意一个类的对象
在运行时判断任意一个类具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理
……

优缺点

优点
- 实现动态创建对象和编译，具有很大的灵活性
缺点
- 对性能有影响。反射是一种解释操作，慢于直接执行相同操作

主要API

java.lang.Class：代表一个类
java.lang.reflect.Method：代表类的方法
java.lang.reflect.Field：代表类的成员变量
java.lang.reflect.Constructor：代表类的构造器

Class类

一个类在内存中只有一个Class对象（c1, c2, c3的hashCode值相同）
一个类被加载后，类的整个结构都会被封装在Class对象中

public class Test01 {
    public static void main(String[] args) throws ClassNotFoundException {
        //通过反射获取类的class对象
        Class c1 = Class.forName("com.chachan53.class13annotation.reflection.User");
        System.out.println(c1);

        Class c2 = Class.forName("com.chachan53.class13annotation.reflection.User");
        Class c3 = Class.forName("com.chachan53.class13annotation.reflection.User");

        //一个类在内存中只有一个Class对象
        //一个类被加载后，类的整个结构都会被封装在Class对象中
        System.out.println(c1.hashCode());//1956725890
        System.out.println(c2.hashCode());//1956725890
        System.out.println(c3.hashCode());//1956725890
    }
}

//实体类：只有属性，可以用pojo或entity表示
class User{...}

Class类的性质

一个Class对象包含了结构的有关信息

Class本身也是类
Class对象只能由系统建立对象
一个加载的类在JVM中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中.class文件
每个类的实例都会记得由哪个Class实例生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，需要先得到相对应的Class对象才能进行其他操作

获取Class类的实例

已知具体类没通过类的class属性获取，最可靠，性能最高
- Class clazz = Person.class;
已知某个类的实例，调用该实例的getClass()方法获取Class对象
- Class clazz = person.getClass()
已知类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出CLassNotFoundException
- Class clazz = Class.forName("demo01.Student")
内置基本属性类型可以直接使用类名.Type
利用ClassLoader

public class Test02 {
    public static void main(String[] args) throws ClassNotFoundException {
        //学生类
        Person person = new Student();

        //1.通过对象获得
        Class c1 = person.getClass();
        System.out.println(c1.hashCode());

        //2. forName获得
        Class c2 = Class.forName("com.chachan53.class13annotation.reflection.Student");
        System.out.println(c2.hashCode());

        //3. 通过类名.class获得
        Class c3 = Student.class;
        System.out.println(c3.hashCode());

        //4. 内置类型的包装类的TYPE属性
        Class c4 = Integer.TYPE;

        //获得父类类型
        Class c5 = c1.getSuperclass();
        System.out.println(c5);
    }
}

定义类：

class Person{
    public String name;
    public Person(){}
    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Student extends Person{
    public Student(){
        this.name = "学生";
    }
}

class Teacher extends Person{
    public Teacher(){
        this.name = "老师";
    }
}

拥有Class对象的类型

class：外部类、成员（成员内部类，静态内部类），局部内部类，匿名内部类
interface：接口
[]：数组
enum：枚举
annotation：注解@interface
primitive type：基本数据类型
void

public static void main(String[] args) {
    Class c1 = Object.class; //类
    Class c2 = Comparable.class; //接口
    Class c3 = String[].class; //一维数组
    Class c4 = int[][].class; //二维数组
    Class c5 = Override.class; //注解
    Class c6 = ElementType.class; //枚举
    Class c7 = Integer.class; //基本数据类型
    Class c8 = void.class; //void
    Class c9 = Class.class; //Class

    System.out.println(c1); //class java.lang.Object
    System.out.println(c2); //interface java.lang.Comparable
    System.out.println(c3); //class [Ljava.lang.String;
    System.out.println(c4); //class [[I
    System.out.println(c5); //interface java.lang.Override
    System.out.println(c6); //class java.lang.annotation.ElementType
    System.out.println(c7); //class java.lang.Integer
    System.out.println(c8); //void
    System.out.println(c9); //class java.lang.Class
}

只要元素类型和维度相同，就是同一个类

int[] a = new int[10];
int[] b = new int[100];
System.out.println(a.getClass().hashCode()); //1956725890
System.out.println(b.getClass().hashCode()); //1956725890

进一步学习：反射的应用

posted @ 2022-04-19 11:39 chachan53 阅读(35) 评论(0) 编辑收藏举报

刷新页面返回顶部

chachan53