【读码JDK】-带你详细了解lang.Class类（一）-阿里云开发者社区

该文章根据JDK中的API进行逐个讲解，自己的理解、使用案例和总结，同时为了避免不可抗拒因素产生的误导，我会带上JDK原有的注释，便于读者自行判断。
Class类里面方法实在太多了，分两篇文章，我自己整理都整理了很久。

java.lang.Class类Api介绍及测试

测试实体

首先这是本篇文章用到的几个测试类，Animal是顶级父类，Person继承了Animal，ChinesePeople 继承自Person

//顶级父类
public interface Animal {
}

//人类
public class Person implements Animal {
    public String name;
    public int age;
    private String address;
    Status status;

    public Status getStatus() {
        return status;
    }

    public void setStatus(Status status) {
        this.status = status;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public <F> String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("name=" + name);
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                Objects.equals(name, person.name) &&
                Objects.equals(address, person.address);
    }

    @Override
    public int hashCode() {
        return 111;
    }
}

//中国人继承人类
public class ChinesePeople extends Person {

    static {
        System.out.println("加载类");
    }

    public ChinesePeople() {
        System.out.println("实例化类，我是中国人");
    }

    public ChinesePeople(String name) {
        System.out.println(name + "，我是中国人");
    }

    public class ZjPeople {

    }
}

toGenericString

返回描述Class的字符串，包括修饰符，和类型参数的信息

System.out.println(this.getClass().toGenericString()); 
//public class lang.ClassTest

forName

该方法我们经常在反射的时候用到，用于将类文件加载到ClassLoader中

 /**
  * 返回与给定字符串名称相关联的类或接口的Class对象
  *  此方法等效于：
  *  Class.forName(className, true, currentLoader)
  * 其中currentLoader表示当前类的定义类加载器。
  * 例如，以下代码片段返回名为java.lang.Thread的类的运行时类描述符：
  *  Class t = Class.forName("java.lang.Thread")
  * 调用forName("X")会导致名为X的类被初始化。
  *
  * 参数：
  * className - 类的全限定名
  */
 Class chinesePeople = Class.forName("lang.ChinesePeople");

 /**
  * 使用指定的类加载器，加载给定字符串名称相关联的Class对象
  *
  * 参数：
  * name - 类的全限定名
  * initialize - true 代表加载类，false代表不加载类
  * loader - 指定的类加载器
  */
 Class chinessPeople1 = Class.forName("lang.ChinesePeople", true, this.getClass().getClassLoader());

 /**
  * 返回指定模块中，与给定字符串相关的Class对象
  * 不会初始化类
  *
  * 参数：
  *  module - 模块
  *  name - 类的全限定名
  */
 //todo
 //Class.forName();

newInstance

创建Class对象的实例会执行无参构造器

在JDK9中过期，使用clazz.getDeclaredConstructor().newInstance()替

Class chinesePeople = Class.forName("lang.ChinesePeople");
ChinesePeople chinesePeople2 = (ChinesePeople) chinesePeople.newInstance();
ChinesePeople chinesePeople3 = (ChinesePeople) chinesePeople.getDeclaredConstructor().newInstance();
/**
 * 加载类
 * 实例化类，我是中国人
 * 实例化类，我是中国人
 */

isInstance

确定指定的Object是否与该Class表示的对象赋值兼容。

/**
 * 确定此Class对象表示的类或接口是否与指定的Class参数表示的类或接口相同，或者是其超类或超接口。如果是，则返回true ；否则返回false 。如果此Class对象表示原始类型，则如果指定的Class参数正是此Class对象，则此方法返回true ；否则返回false 。
 * 具体来说，该方法测试指定的Class参数表示的类型是否可以通过恒等转换或扩展引用转换转换为该Class对象表示的类型。有关详细信息，请参阅Java 语言规范的第 5.1.1 和 5.1.4 节。
 * 参形：
 * cls – 要检查的Class对象
 * 返回值：
 * boolean值，指示是否可以将cls类型的对象分配给此类的对象
 * 抛出：
 * NullPointerException – 如果指定的 Class 参数为 null。
 * 自：
 * 1.1
 */

//指定的对象实例是否与该类对象兼容，是否可以转换
ChinesePeople chinesePeople = new ChinesePeople();
Person person = new Person();
//父类不能转换为子类
System.out.println(chinesePeople.getClass().isInstance(person)); //false
//子类可以转换为父类
System.out.println(person.getClass().isInstance(chinesePeople)); //true
System.out.println(Person.class.isInstance(chinesePeople)); //true

//对象是本身类的一个实例
System.out.println(ChinesePeople.class.isInstance(chinesePeople)); //true
//不是一个对象
System.out.println(ChinesePeople.class.isInstance(ChinesePeople.class)); //false

//如果object是数组对象
Integer[] integers = new Integer[0];
System.out.println(Number.class.isInstance(integers)); //false
//除了这种情况，还有其他等于true的情况吗？？
System.out.println(new Integer[0].getClass().isInstance(integers)); //true

Person[] persons = new Person[0];
ChinesePeople[] chinesePeoples = new ChinesePeople[0];
Person[] chinesePeople2 = new ChinesePeople[0];
//chinesePeople是Person的子类，兼容
System.out.println(persons.getClass().isInstance(chinesePeoples));//true
//chinesePeople2 是ChinesePeople对象数组，与chinesePeoples兼容
System.out.println(chinesePeoples.getClass().isInstance(chinesePeople2));//true


//Object是所有类的超类
System.out.println(Object.class.isInstance(chinesePeople)); //true

//------------instanceof-------------------
System.out.println(chinesePeoples instanceof Person[]);

这个isInstance 与 instanceof 用法是类似的，但是isInstance表示右边的入参可以与左边的类对象兼容，跟人类从左往右的习惯是反的，这个方法是以前Jdk1.1老版本的方法，后期建议使用instanceof

isAssignableFrom

/**
 * 确定此Class对象表示的类或接口是否与指定的Class参数表示的类或接口相同，或者是其超类或超接口。如果是，则返回true ；否则返回false 。如果此Class对象表示原始类型，则如果指定的Class参数正是此Class对象，则此方法返回true ；否则返回false 。
 * 具体来说，该方法测试指定的Class参数表示的类型是否可以通过恒等转换或扩展引用转换转换为该Class对象表示的类型。有关详细信息，请参阅Java 语言规范的第 5.1.1 和 5.1.4 节。
 * 参形：
 * cls – 要检查的Class对象
 * 返回值：
 * boolean值，指示是否可以将cls类型的对象分配给此类的对象
 * 抛出：
 * NullPointerException – 如果指定的 Class 参数为 null。
 * 自：
 * 1.1
 */

@Test
public void isAssignableFrom() throws ClassNotFoundException {

    Class chinesePeople = Class.forName("lang.ChinesePeople");
    //同类
    assert chinesePeople.isAssignableFrom(ChinesePeople.class);
    //Person 是ChinesePeople 的超类
    assert Person.class.isAssignableFrom(chinesePeople);
    // ChinesePeople 不是Person的超类
    assert !chinesePeople.isAssignableFrom(Person.class);
}

这个也是表示类对象时候相同，或者兼容（超类或接口），但该方法表示左边的对象是否右边参数的超类、接口或同对象，是顺序的,符合人的思维习惯

isInterface

/**
 * 确定指定的类对象是否表示接口类型
 */

@Test
public void isInterface() {

    assert Animal.class.isInterface();
    assert !ChinesePeople.class.isInterface();
    //注解也是接口
    assert Name.class.isInterface();
}

isArray

/**
 * 确定指定的类对象是否表示数组类型
 */

    @Test
    public void isArray() {

        ChinesePeople[] chinesePeopleAry = new ChinesePeople[10];
        //确定此类对象是否表示数组类
        assert chinesePeopleAry.getClass().isArray();
    }

isPrimitive

/**
 * 确定指定的类对象是否表示原型类型
 * 
 * 只有一下几种才返回真
 Boolean.TYPE , 
 Character.TYPE , 
 Byte.TYPE ， 
 Short.TYPE ， 
 Integer.TYPE ， 
 Long.TYPE , 
 Float.TYPE ，
 Double.TYPE , 
 Void.TYPE
 */

    @Test
    public void isPrimitive() {
        System.out.println(Boolean.TYPE.isPrimitive()); //true
        System.out.println(Person.class.isPrimitive()); //false

        Integer[] integers = new Integer[0];
        System.out.println(integers.getClass().isPrimitive()); //false
        Integer a = 1;
        System.out.println(a.getClass().isPrimitive());//false
    }

这个方法也是JDK1.1时代的，感觉很鸡肋，没什么用

isAnnotation

确定此类对象是否表示注解类型

        System.out.println(Test.class.isAnnotation()); //true
        System.out.println(Test.class.isInterface()); //true

isSynthetic

确定此类是否表示合成类

System.out.println(ChinesePeople.class.isSynthetic()); //false

扩展：什么是合成类

官方说明：
According to the JVM Spec: "A class member that does not appear in the source code must be marked using a Synthetic attribute." Also, "The Synthetic attribute was introduced in JDK release 1.1 to support nested classes and interfaces."
根据JVM规范：“源代码中未出现的类成员必须使用合成属性进行标记。”此外，“合成属性在JDK 1.1版中引入，以支持嵌套类和接口。”

就是说Synthetic是JVM自动生成的，私有内部类编译后会生成一个"mainClass$1.class"的类，该类带有synthetic class，表示合成类。

为了在该文，不引入太多内容,我另外起了一篇文章。
synthetic 的详细介绍见：【读码JDK】Java synthetic的介绍

getName

/**
 * 返回此类对象表示的实体名称（类，接口，数组类，基本类型或void）
 * 如果此类对象表示不是数组类型的引用类型，则返回该类的二进制名称，如The Java™ Language Specification所指定。
 * <p>
 * 如果此类对象表示基本类型或void，则返回的名称是String等于与基本类型或void对应的Java语言关键字。
 * <p>
 * 如果此类对象表示一个数组类，则该名称的内部形式由元素类型的名称组成，前面是一个或多个表示数组嵌套深度的“ [ ”字符。
 */

       System.out.println(ChinesePeople.class.getName());
       System.out.println(Animal.class.getName());
       System.out.println(String.class.getName());
       System.out.println(byte.class.getName());
       System.out.println((new Object[3]).getClass().getName());
       System.out.println((new Object[1][2]).getClass().getName());
       /**
        * lang.ChinesePeople
        * lang.Animal
        * java.lang.String
        * byte
        * [Ljava.lang.Object;
        * [[Ljava.lang.Object;
        */

getClassLoader

/**
 * 返回该类的类加载器。 某些实现可能使用null来表示引导类加载器。 如果此类由引导类加载器加载，则此方法将在此类实现中返回null。
 * 如果此对象表示基本类型或void，则返回null。
 */

        System.out.println(ChinesePeople.class.getClassLoader());
        System.out.println(String.class.getClassLoader());

        /**
         * jdk.internal.loader.ClassLoaders$AppClassLoader@47f37ef1
         * null
         */

getModule

首先ChinesePeople是定义在lang包中，并且定义了一个model类，暴露出lang包

module java.test {
    requires java.desktop;
    exports io;
    exports lang;
}

看看官方注释：

/**
 * 返回此类或接口所属的模块。
 * 如果此类表示数组类型，则此方法返回元素类型的模块 。
 * 如果此类表示基本类型或void，则返回java.base模块的模块对象。
 * 如果此类位于未命名的模块中，则返回 模块的类加载器的unnamed 模块 。
 */

        System.out.println(List.class.getModule());
        System.out.println(ChinesePeople.class.getModule());
        System.out.println(new Integer[0].getClass().getModule());
        System.out.println(String.class.getModule());

        /**
         * module java.base
         * module java.test
         * module java.base
         * module java.base
         */

getTypeParameters

/**
 * 返回泛型的变量名称。
 * 如果基础泛型声明未声明类型变量，则返回长度为0的数组。
 */

        TypeVariable[] typeVariables = List.class.getTypeParameters();
        System.out.println(Arrays.toString(typeVariables));
        TypeVariable[] typeVariables1 = Animal.class.getTypeParameters();
        System.out.println(typeVariables1.length);
        TypeVariable[] typeVariables2 = TreeMap.class.getTypeParameters();
        System.out.println(Arrays.toString(typeVariables2));

        /**
         * [E]
         * 0
         * [K, V]
         */

返回结果即为类的泛型名称

getSuperclass

/**
 * 返回表示此类表示的实体的直接超类（类，接口，基本类型或void）的类 。
 * 如果此类表示Object类，接口，基本类型或void，则返回null。
 * 如果此对象表示数组类，则返回表示Object类的类对象。
 */

        //ChinesePeople 继承Person，返回class lang.Person
       System.out.println(ChinesePeople.class.getSuperclass());
       //Person实现了Animal，Person的超类是class java.lang.Object
       System.out.println(Person.class.getSuperclass());
       //Bird实现了Animal，同理，所以该方法说的超类是指继承的父类
       System.out.println(Bird.class.getSuperclass());
       //Object、接口、原始类型、void返回null
       System.out.println(Animal.class.getSuperclass());
       System.out.println(Object.class.getSuperclass());
       System.out.println(byte.class.getSuperclass());
       System.out.println(void.class.getSuperclass());
       //数组类型返回Object
       System.out.println(new Object[0].getClass().getSuperclass());
       //枚举的超类
       System.out.println(Status.class.getSuperclass());

       /**
        * class lang.Person
        * class java.lang.Object
        * class java.lang.Object
        * null
        * null
        * null
        * null
        * class java.lang.Object
        * class java.lang.Enum
        */

getGenericSuperclass

/**
 * 返回Type表示此所表示的实体（类，接口，基本类型或void）的直接超类类 。
 * 如果超类是参数化类型，则返回的Type对象必须准确反映源代码中使用的实际类型参数。
 * 如果之前尚未创建超类，则创建表示超类的参数化类型。
 * 有关参数化类型的创建过程的语义，请参阅ParameterizedType的声明。
 * 如果此类表示Object类，接口，基本类型或void，则返回null。
 * 如果此对象表示数组类，则返回表示Object类的类对象。
 */

        Type type = ChinesePeople.class.getGenericSuperclass();
        System.out.println(type.getTypeName());
        Type type1 = Person.class.getGenericSuperclass();
        System.out.println(type1.getTypeName());
        //返回null
        Type type2 = Object.class.getGenericSuperclass();
        System.out.println(type2);
        Type type3 = Animal.class.getGenericSuperclass();
        System.out.println(type3);

        /**
         * lang.Person
         * java.lang.Object
         * null
         * null
         */

跟getSuperclass用法很类似，只不过getSuperclass返回的是Class, getGenericSuperclass返回的是Type，而Class类实现了Type接口

getPackageName

/**
 * 返回完全限定的包名称。
 * 如果此类是顶级类，则此方法返回该类所属的包的完全限定名称，如果该类位于未命名的包中，则返回空字符串。
 * 如果此类是成员类，则此方法等效于在封闭类上调用getPackageName() 。
 * 如果此类是本地类或匿名类，则此方法等效于在封闭方法或封闭构造函数的声明类上调用getPackageName() 。
 * 如果此类表示数组类型，则此方法返回元素类型的包名称。如果此类表示原始类型或 void，则返回包名称“ java.lang ”。
 * 返回值：
 * 完全限定的包名
 * 自：9
 */

        System.out.println(ChinesePeople.class.getPackageName());
        System.out.println(ChinesePeople.ZjPeople.class.getPackageName());
        System.out.println(Object.class.getPackageName());
        System.out.println(new Object[0].getClass().getPackageName());

        Integer[] integers = new Integer[0];
        System.out.println(integers.getClass().getPackageName());
        Dog[] dogs = new Dog[0];
        System.out.println(dogs.getClass().getPackageName());

        /**
         * lang
         * lang
         * java.lang
         * java.lang
         * java.lang
         * lang.test
         */

getInterfaces

/**
 * 返回此类的接口
 * 如果此对象表示类，则返回值是一个数组，其中包含表示该类直接实现的所有接口的对象。
 * 数组中接口对象的顺序对应于此对象所表示的类的声明的implements子句中的接口名称的顺序。 例如，鉴于声明：
 * class Shimmer implements FloorWax, DessertTopping { ... }
 * 假设的值s是实例Shimmer ; 表达式的值：
 * s.getClass().getInterfaces()[0]
 * 是类对象，表示接口FloorWax ; 和价值：
 * s.getClass().getInterfaces()[1]
 * 是类对象，表示接口DessertTopping 。
 * 如果此对象表示接口，则该数组包含表示由接口直接扩展的所有接口的对象。 数组中接口对象的顺序对应于此对象表示的接口声明的extends子句中接口名称的顺序。
 * 如果此对象表示不实现接口的类或接口，则该方法返回长度为0的数组。
 * 如果此对象表示基本类型或void，则该方法返回长度为0的数组。
 * 如果此类对象表示阵列类型， Cloneable顺序返回接口Cloneable和java.io.Serializable 。
 */

        //ChinesePeople继承的Person,没有实现接口
        Class[] interfaces = ChinesePeople.class.getInterfaces();
        System.out.println(Arrays.toString(interfaces)); //0
        //Person实现了接口Animal
        Class[] interfaces2 = Person.class.getInterfaces();
        System.out.println(Arrays.toString(interfaces2)); //[interface lang.Animal]
        //Collection接口返回继承的接口
        System.out.println(Arrays.toString(Collection.class.getInterfaces())); //[interface java.lang.Iterable]
        //ArrayList类按顺序返回其实现的接口，不返回继承的类
        //[interface java.util.List, interface java.util.RandomAccess, interface java.lang.Cloneable, interface java.io.Serializable]
        System.out.println(Arrays.toString(ArrayList.class.getInterfaces()));

getGenericInterfaces

/**
 * 同getInterfaces，只是返回结果为Type类型
 * 如接口是泛型，则返回带泛型名的接口
 */

       System.out.println(Arrays.toString(Collection.class.getGenericInterfaces()));
       //[java.lang.Iterable<E>]

getComponentType

/**
 * 返回表示数组的组件类型的类 。
 * <p>
 * 如果此类不表示数组类，则此方法返回null
 */

        Class componentType = new Object[1].getClass().getComponentType();
        System.out.println(componentType); //class java.lang.Object

        System.out.println(new Integer[0].getClass().getComponentType());//class java.lang.Integer

        //ChinesePeople不是数组
        Class componentType2 = ChinesePeople.class.getComponentType();
        System.out.println(componentType2); //null

getModifiers

/**
 * 返回此类或接口的Java语言修饰符，以整数编码。
 * 修饰符由Java虚拟机的常数为public ， protected ， private ， final ， static ， abstract和interface ;
 * 它们应该使用Modifier类的方法解码。
 */

        System.out.println(ChinesePeople.class.getModifiers()); //1
        //Modifier提供了各种方法判断获取的整型代表public，还是protected
        System.out.println(Modifier.isPublic(ChinesePeople.class.getModifiers()));

getSigners

/**
 * 获取此类的签名者
 * 此类的签名者，如果没有签名者则为null。 特别是，如果此对象表示基本类型或void，则此方法返回null。
 * //todo 具体怎么给类签名还不清楚，不过这个方法在Java内部经常看到
 */

        assert ChinesePeople.class.getSigners() == null;
        assert int.class.getSigners() == null;
        assert Void.class.getSigners() == null;

getEnclosingMethod

/**
 * 如果此类对象表示方法中的本地或匿名类，则返回方法对象，该对象表示基础类的直接封闭方法。
 * 否则返回null 。
 * 特别是，如果基础类是由类型声明，实例初始化程序或静态初始化程序直接包含的本地或匿名类，则此方法返回null 。
 */

    public void getEnclosingMethod() {

        Runnable runnable = () -> {
        };
        Method method = runnable.getClass().getEnclosingMethod();
        System.out.println(method); //null

        Method method1 = getPerson().getClass().getEnclosingMethod();
        System.out.println(method1); //private lang.Person lang.ClassTest.getPerson()
    }

    private Person getPerson() {
        class BjPerson extends Person {

        }

        return new BjPerson();
    }

getEnclosingConstructor

/**
 * 如果此类对象表示构造函数中的本地或匿名类，则返回构造器对象，该对象表示基础类的直接封闭构造函数。
 * 否则返回null 。
 * 特别是，如果基础类是由类型声明，实例初始化程序或静态初始化程序直接包含的本地或匿名类，则此方法返回null 。
 */

        class OuterClass {
            public Object test;

            public OuterClass() {
                class InnerClass {
                }
                test = new InnerClass();
            }
        }
        Constructor constructor = new OuterClass().test.getClass().getEnclosingConstructor();
        assert constructor.getName().equals("lang.ClassTest$1OuterClass");

【读码JDK】-带你详细了解lang.Class类（一）

java.lang.Class类Api介绍及测试

测试实体

toGenericString

forName

newInstance

isInstance

isAssignableFrom

isInterface

isArray

isPrimitive

isAnnotation

isSynthetic

扩展：什么是合成类

getName

getClassLoader

getModule

getTypeParameters

getSuperclass

getGenericSuperclass

getPackageName

getInterfaces

getGenericInterfaces

getComponentType

getModifiers

getSigners

getEnclosingMethod

getEnclosingConstructor

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【读码JDK】-带你详细了解lang.Class类（一）

java.lang.Class类Api介绍及测试

测试实体

toGenericString

forName

newInstance

isInstance

isAssignableFrom

isInterface

isArray

isPrimitive

isAnnotation

isSynthetic

扩展：什么是合成类

getName

getClassLoader

getModule

getTypeParameters

getSuperclass

getGenericSuperclass

getPackageName

getInterfaces

getGenericInterfaces

getComponentType

getModifiers

getSigners

getEnclosingMethod

getEnclosingConstructor

热门文章

最新文章

相关课程

相关电子书