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

举报
阿提说说 发表于 2022/06/19 10:17:06 2022/06/19
【摘要】 给你详细讲解Class类近80个方法

在这里插入图片描述
【读码JDK】java.lang包目录

该文章根据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");
【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200