Java类型信息之RTTI

最新推荐文章于 2021-08-21 09:50:30 发布
最新推荐文章于 2021-08-21 09:50:30 发布
阅读量171 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oowgsoo/article/details/81837468
版权

软件工程的一个核心问题就是软件的复用和扩展。面向对象思想通过封装，继承，派生等机制有效地解决了这个问题。但需求总是变幻莫测，不可琢磨，在面向对象这栋恢宏的大厦旁，还漂浮着一朵乌云，从而导致了RTTI的登场。

正是因为RTTI的存在，在软件世界里，无间道是会分分钟暴露的：

https://img3.mukewang.com/5b78cdfc0001a24a04940277.jpg

1.缘起

考虑一下面向对象思想发源地之一的CAD系统：

package typeinfo._01_rtti;

import java.util.Arrays;
import java.util.List;

interface Shape {
    void draw();
}

class CAD {
    public void draw(List<Shape> shapes) {
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle draw()");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square draw()");
    }
}

class Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Triangle draw()");
    }
}

public class Shapes {
    public static void main(String[] args) {
        List<Shape> shapes = Arrays.asList(
                new Circle(), new Square(), new Triangle()
        );

        CAD cad = new CAD();
        cad.draw(shapes);
    }
}

输出结果：

Circle draw()
Square draw()
Triangle draw()

代码点评：

Shape是基类，根据多态机制，Shape引用可以被它的子类引用赋值，并通过动态绑定在虚函数draw调用时正确调用子类的draw。

依靠这种机制，我们可以轻松的在上层的CAD类中写出通用的draw方法，而不用管Shape到底会有多少子类。

现在忽然来了新的需求，要求CAD在draw的时候把用户指定类型的对象高亮显示，假设用户指定了Circle类型，那就是要求把当前图形中的所有的Circle对象高亮显示。因为上层的CAD代码无法分辨具体的子类类型，所以功能无法实现。

痛定思痛，这些面向对象的大师们决定引入RTTI（Run-Time Type Identification）运行时类型识别，简单的说就是运行时你只要给我一个引用，就我能准确的告诉你它是什么具体类型的。

尽管RTTI名声不好，大师们的建议是能少用就少用，但是具有讽刺意味的是，几乎没有哪门语言能跳过RTTI，不同的只是各种各样的语法区别：

  • Python语言的type

  • Java语言的getClass

  • javascript语言的typeof

  • C++语言的typeid

  • C#语言的GetType

  • 。。。

2.Java语言的class

Java语言的class其实是一个Class类的对象，任何类都有一个这样的对象，实际上，这是对象又是Java类加载器加载类时自动带上的，要理清这些角色之间的复杂关系，请看下图：

https://img1.mukewang.com/5b78ce510001dfc008100650.jpg

  1. 所有new出来的对象共享该类型的class对象

  2. class对象是Class类的一个实例

  3. Class类是被ClassLoader带进来的

  4. ClassLoader通过加载class字节码导入类

口说无凭，直接来段测试代码吧：

    @Test
    public void testClassLevel() {
        class Test {
        }

        Test a = new Test();
        System.out.println(a.getClass());
        Test b = new Test();
        System.out.println(b.getClass());

        System.out.println(a.getClass() == a.getClass());

        System.out.println(Test.class);
        System.out.println(Test.class.getClassLoader());
    }

输出结果：

class typeinfo._01_rtti.ClassClassTest$1Test
class typeinfo._01_rtti.ClassClassTest$1Test
true
class typeinfo._01_rtti.ClassClassTest$1Test
jdk.internal.loader.ClassLoaders$AppClassLoader@726f3b58

代码点评：

new出来的对象可以通过getClass得到该类型的class对象

所有new出来的对象getClass得到的class对象都是同一个

class对象可以通过Test.class的形式快速引用

class对象可以通过getClassLoader得到类加载器

关于类加载器的细节，将单独有一篇文章介绍

2.引用class

引用class最简单的方式就是通过XXX.class的语法直接引用：

    public void print(Class meta) {
        System.out.println(meta);
    }

    @Test
    public void testClassClass() {
        print(boolean.class);
        print(char.class);
        print(byte.class);
        print(short.class);
        print(int.class);
        print(long.class);
        print(float.class);
        print(double.class);

        print(void.class);
        print(Object.class);
        print(String.class);
    }

输出结果：

boolean
char
byte
short
int
long
float
double
void
class java.lang.Object
class java.lang.String

代码点评：

没错，基本类型也有class，甚至是void也有class

class及其Class就是Java类型体系的核心

还有内置的数组呢？同样不能例外：

    @Test
    public void testClassClassArray() {
        print(boolean[].class);
        print(char[].class);
        print(byte[].class);
        print(short[].class);
        print(int[].class);
        print(long[].class);
        print(float[].class);
        print(double[].class);

        //print(void[].class);
        print(Object[].class);
        print(String[].class);
    }

输出结果：

class [Z
class [C
class [B
class [S
class [I
class [J
class [F
class [D
class [Ljava.lang.Object;
class [Ljava.lang.String;

代码点评：

void[]是不存在的

输出的这些奇怪的字符，这是历史原因造成的，其实它就表示数组

通过对象得到class要用getClass：

    @Test
    public void testClassGetClass() {
        Boolean t = true;
        Character c = 'A';
        Byte b = 0;
        Short s = 0;
        Integer i = 0;
        Long l = 0L;
        Float f = 1.0f;
        Double d = 1.0;

        print(t.getClass());
        print(c.getClass());
        print(b.getClass());
        print(s.getClass());
        print(i.getClass());
        print(l.getClass());
        print(f.getClass());
        print(d.getClass());

        //Void v = new Void();
        Object obj = new Object();
        String str = new String();
        //print(v.getClass());
        print(obj.getClass());
        print(str.getClass());
    }

输出结果：

class java.lang.Boolean
class java.lang.Character
class java.lang.Byte
class java.lang.Short
class java.lang.Integer
class java.lang.Long
class java.lang.Float
class java.lang.Double
class java.lang.Object
class java.lang.String

代码点评：

基本类型不能生成对象引用，只好用它们的包装类对象引用

除了Void，其它的与XXX.class是一致的

其实数组也是对象，所以下面的代码也是成立的：

    @Test
    public void testClassGetClassArray() {
        boolean[] t = {true};
        char[] c = {'A'};
        byte[] b = {0};
        short[] s = {0};
        int[] i = {0};
        long l[] = {0L};
        float f[] = {1.0f};
        double[] d = {1.0};

        print(t.getClass());
        print(c.getClass());
        print(b.getClass());
        print(s.getClass());
        print(i.getClass());
        print(l.getClass());
        print(f.getClass());
        print(d.getClass());

        Object[] obj = {new Object()};
        String[] str = {new String()};
        print(obj.getClass());
        print(str.getClass());
    }

输出结果：

class [Z
class [C
class [B
class [S
class [I
class [J
class [F
class [D
class [Ljava.lang.Object;
class [Ljava.lang.String;

对于Java的基本类型，还可以通过XXX.TYPE的形式引用class，这是基本类型所特有的绿色通道：

    @Test
    public void testClassType() {
        print(Boolean.TYPE);
        print(Character.TYPE);
        print(Byte.TYPE);
        print(Short.TYPE);
        print(Integer.TYPE);
        print(Long.TYPE);
        print(Float.TYPE);
        print(Double.TYPE);

        print(Void.TYPE);
        //print(Object.TYPE);
        //print(String.TYPE);
    }

输出结果：

boolean
char
byte
short
int
long
float
double
void

3.class与泛型

原则上，所有的class都是Class类的对象，但是这太粗略了。我们可以通过泛型进一步细化Class类：

    @Test
    public void testGeneric() {
        Class intClass = int.class;
        intClass = double.class;

        Class<Integer> genericIntClass = int.class;
        genericIntClass = Integer.class; // Same thing
        // genericIntClass = double.class; // Illegal
    }

代码点评：

默认的Class即可以引用int.class，也可以引用double.class

Class<Integer>就只能引用int.class了，不可以引用double.class

当然了，在泛型的世界里，更习惯用通配符Class<?>代替Class，以表明它那高贵的泛型身份：

    @Test
    public void testWildcard() {
        Class<?> intClass = int.class;
        intClass = double.class;
        intClass = String.class;
    }

当然了，还不能忘了泛型的限定符：

    @Test
    public void testBounded() {
        Class<? extends Number> numberClass = int.class;
        numberClass = double.class;
        numberClass = Number.class;
        //numberClass = String.class;
    }

这里通过限定符的限制，有效的避免了String.class的引用。

oowgsoo
关注
专栏目录
Java进阶教程之运行时类型识别RTTI机制
09-04
RTTI的核心在于Java的`Class`类，它提供了获取对象运行时类型信息的能力。每种Java类在运行时都有一个与之关联的`Class`对象，这个对象包含了类的所有元数据，如类名、包名、接口、方法等。通过`Class`对象，我们...
jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to java.net.URLClassLoa
yanzi920403的博客
02-25 1万+
今天遇到了个奇怪的问题，部署到新环境后，动态加载类的功能报错。 Exception in thread "main" java.lang.RuntimeException: java.lang.ClassCastException: jdk.internal.loader.ClassLoaders$AppClassLoader (in module: java.base) cannot be cast to java.net.URLClassLoader (in module: java.base)
JVM（一）：jvm的类加载机制解析
lory_li的博客
03-17 206
先看一个示例：        package com.lory.jvm; class Singleton { private static Singleton singleton = new Singleton(); public static int count1; public static int count2 = 0; private Single...
class jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to class java.net.URLClassLoade
梦里逆天的博客
08-26 1万+
class jdk.internal.loader.ClassLoadersAppClassLoadercannotbecasttoclassjava.net.URLClassLoader(jdk.internal.loader.ClassLoadersAppClassLoader cannot be cast to class java.net.URLClassLoader (jdk.internal.loader.ClassLoadersAppClassLoadercannotbecasttoclass
jeefast启动报错class jdk.internal.loader.ClassLoaders$AppClassLoader
KingEverything的博客
03-17 2500
1.报错信息： Exception in thread "main" java.lang.ClassCastException: class jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to class java.net.URLClassLoader (jdk.internal.loader.ClassLoaders...
举例讲解Java的RTTI运行时类型识别机制
09-02
Java的RTTI（Runtime Type Information，运行时类型信息）机制是Java语言的一个重要特性，它允许程序在运行时检查对象的实际类型。RTTI使得在编译时未知类型的对象能够在运行时进行适当的处理，从而增强了代码的灵活...
Java的RTTI和反射机制代码分析
08-29
Java的RTTI（运行时类型识别）和反射机制是两种强大的工具，它们允许程序在运行时检查和操作类的信息及对象。RTTI是Java的一种特性，它使得在编译后的程序中仍然可以在运行时获取对象的实际类型信息。这在处理多态性...
Java在运行时识别类型信息的方法详解
08-26
Java 中的运行时类型识别（RTTI）机制是指在程序执行过程中，Java 虚拟机（JVM）可以识别出对象的真正类型信息，而不仅仅是引用类型。这项机制是通过 Class 类实现的。 Class 类是 Java 中的核心类之一，包含了关于...
深入理解Java类型信息(Class对象)与反射机制
01-27
在Java中，Class对象扮演了RTTI的角色，它在运行时提供了识别对象类型和类信息的能力。 传统RTTI假定在编译时已知所有类型，而Java的反射机制则允许在运行时动态地获取和使用类信息。Class类是Java的标准库中的一...
jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to java.net.URLClassLoader
热门推荐
Fighting_Boss的博客
06-06 2万+
final URLClassLoader urlClassLoader = (URLClassLoader) MyClass.class.getClassLoader(); final Method addURL = URLClassLoader.class.getDeclaredMethod("addURL", URL.class); ad...
Java运行时类型信息RTTI
烧水匠
08-10 167
应用程序在运行的时候获取一个对象的类型信息的技术称之为运行时类型信息RTTI（Run-Time Type Identification）。RTTI是C++的一个概念，Java中的RTTI是在《think in java》这本书中作者提出来的，官方文档里面并没有RTTI这个概念。作为学习者不应该纠结于一项技术的命名，而应该关注命名所指代的具体技术或者思想，RTTI指代的是一组在运行时获取对象类型信息...
java.base/jdk.internal.loader.ClassLoaders$AppClassLoader cannot be cast to java.base/java.net.URLCl
zhuyuchao11的博客
01-06 6073
在设置项目的热部署时，需要添加对 spring-boot-devtools 的依赖，因为没有给定版本号，maven默认添加的是 v 1.5.8 版本。当时安装JDK时，看到最新的 jdk-1.9, 就顺手安装了最新版本的JDK. 但是添加依赖之后，项目启动失败，报如下异常 Exception in thread "main" java.lang.ClassCastException: java.
Java9中关于类加载器的新特性
实践求真知
08-21 1134
一 点睛 为了保证兼容性，JDK9 没有从根本上改变三层类加载器架构和双亲委派模型，但为了模块化系统的顺利运行，仍然发生了一些值得被注意的变动。 1 扩展机制被移除，扩展类加载器由于向后兼容性的原因被保留，不过被重命名为平台类加载器(platform class loader)。可以通过 classLoader 的新方法 getPlatformClassLoader() 来获取。 JDK9 是基于模块化进行构建(原来的 rt.jar 和 tools.jar 被拆分成数十个 JMOD 文件)，其中的 J
什么是java rtti_java之RTTI和反射的理解
weixin_33816734的博客
02-22 160
最近在读 Thinking in Java这本书。读到类型信息这一张时，刚开始对书中所说的RTTI和反射彻底混了，不知道有什么联系，有哪些相同点和区别。于是在网上又找了些内容辅助理解，这一章又重新读了一遍，对上面的这些疑问有了自己的答案，想到RTTI和反射时，脑海中有了自己的轮廓。它俩的目的一样：在运行时，识别对象和类的信息。相同点：目的相同；功能都是通过Class类来实现的不同点：RTTI:(...
什么是java rtti_浅析Java RTTI 和 反射的概念
weixin_42468911的博客
02-22 729
一、概念RTTI(Run-Time Type Identification，运行时类型识别)的含义就是在运行时识别一个对象的类型，其对应的类是Class对象，怎么理解这个Class对象呢？如果说类是所有对象方法、属性的集合，那就可以把这个Class对象理解成是所有class的集合，然后利用这个Class对象动态的解析出相关类，并可以获得其构造器和方法等，甚至实例化这个类的对象。开始文章前，先提重要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值