前言：

本文内容：得到Class类的方式、所有类型的Class对象、类加载内存分析

推荐免费Java注解和反射讲解视频：【狂神说Java】注解和反射_哔哩哔哩_bilibili

得到Class类的几种方式

Class类

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。

对于每个类而言，JRE都为其保留一个不变的Class类型的对象。一个Class对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。

  • Class本身也是一个类
  • Class对象只能由系统建立对象
  • 一个加载的类在JVM中只会有一个Class实例
  • 一个Class对象对应的时一个加载到JVM中的一个.class文件
  • 每个类的实例都会记得自己是由哪个Class实例所生成
  • 通过Class可以完整地得到一个类中的所有被加载的结构
  • Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

Class类的常用方法

方法名 功能说明
static ClassforName(String name) 返回指定类名name的Class对象
Object newInstance() 调用缺省构造函数，返回Class对象的一个实例
getName() 返回此Class对象所表示的实体(类，接口，数组类或void)的名称
Class getSuperClass() 返回当前Class对象的父类的Class对象
Class[] getinterfaces() 获取当前Class对象的接口
ClassLoader getClassLoader() 返回该类的类加载器
Constructor[] getConstructors() 返回一个包含某些Constructor对象的数组
Method getMothed(String name,Class… T) 返回一个Method对象，此对象的形参类型为paramType
Field[] getDeclaredFields() 返回Field对象的一个数组

获取Class类的实例

若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高。

1
Class cla = Person.class;

已知某个类的实例，调用该实例的getClass()方法获取Class对象。

1
Class cla = Person.getClass();

已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

1
Class cla = Class.forName("demo01.Student");

内置基本数据类型可以直接用类名.Type

还可以利用ClassLoader

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.jokerdig.reflection;

/**
 * @author Joker大雄
 * @data 2021/9/8 - 13:56
 **/
//测试Class类的创建方式
public class Demo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        Person person = new Student();
        System.out.println("这个人是："+person.name);

        //方法一：通过对象获得
        Class cla1 = person.getClass();
        System.out.println(cla1.hashCode());
        //方法二：forName获得
        Class<?> cla2 = Class.forName("com.jokerdig.reflection.Student");
        System.out.println(cla2.hashCode());
        //方式三：通过类名.class获得
        Class cla3 = Student.class;
        System.out.println(cla3.hashCode());
        //方式四：基本内置类型的包装类都有一个Type属性
        Class<Integer> cla4= Integer.TYPE;
        System.out.println(cla4.hashCode());
        //获得父类类型
        Class cla5 = cla1.getSuperclass();
        System.out.println(cla5.hashCode());

    }
}

class Person{
    public String name;

    public Person() {
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

所有类型的Class对象

  • class：外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类。
  • interface：接口
  • []：数组
  • enum：美剧
  • annotation：注解@interface
  • primitive type：基本数据类型
  • void
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package com.jokerdig.reflection;

import java.lang.annotation.ElementType;

/**
 * @author Joker大雄
 * @data 2021/9/8 - 14:13
 **/
//所有类型的class
public class Demo02 {
    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);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);

        int []a = new int[10];
        int []b = new int[100];
        //只要元素类型和维度一样，就是同一个Class
        System.out.println(a.getClass().hashCode());
        System.out.println(b.getClass().hashCode());
    }
}

类加载内存分析

h74g2D

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

h75PRU

类的加载与ClassLoader的理解

  • 加载：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象。

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

    • 验证：确保加载的类信息符合JVM规范，没有安全方面的问题；
    • 准备：正式未类变量(static)分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配；
    • 解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程;

  • 初始化：

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

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

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

      h7HEUs

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      package com.jokerdig.reflection;

      /**
       * @author Joker大雄
       * @data 2021/9/8 - 14:44
       **/
      public class Demo03 {
          public static void main(String[] args) {
              A a = new A();
              System.out.println(A.m);
              /*
               1.加载到内存，会产生一个类对应class对象
               2.链接，连接结束后m=0
               3.初始化
                 <clinit>(){
                      System.out.println("A类静态代码块初始化");
                      m=300;
                 }
               */
          }
      }
      class A{
          static{
              System.out.println("A类静态代码块初始化");
              m=300;
          }
          static int m=100;
          public A(){
              System.out.println("A类的无参构造初始化");
          }
      }