精华内容
下载资源
问答
  • 深入理解Java类型信息(Class对象)与反射机制

    万次阅读 多人点赞 2017-05-01 23:19:19
    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权) ...深入理解Java类型信息(Class对象)与反射机制 深入理解Java枚举类型(enum) 深入理解Java注解类型(@Annotation) 深入理解

    【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
    http://blog.csdn.net/javazejian/article/details/70768369
    出自【zejian的博客】

    关联文章:

    深入理解Java类型信息(Class对象)与反射机制

    深入理解Java枚举类型(enum)

    深入理解Java注解类型(@Annotation)

    深入理解Java并发之synchronized实现原理

    深入理解Java内存模型(JMM)及volatile关键字

    深入理解Java类加载器(ClassLoader)

    本篇主要是深入对Java中的Class对象进行分析,这对后续深入理解反射技术非常重要,主要内容如下:

    深入理解Class对象

    RRTI的概念以及Class对象作用

    认识Class对象之前,先来了解一个概念,RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thinking in Java》一书,其作用是在运行时识别一个对象的类型和类的信息,这里分两种:传统的”RRTI”,它假定我们在编译期已知道了所有类型(在没有反射机制创建和使用类对象时,一般都是编译期已确定其类型,如new对象时该类必须已定义好),另外一种是反射机制,它允许我们在运行时发现和使用类型的信息。在Java中用来表示运行时类型信息的对应类就是Class类,Class类也是一个实实在在的类,存在于JDK的java.lang包中,其部分源码如下:

    public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type, AnnotatedElement {
        private static final int ANNOTATION= 0x00002000;
        private static final int ENUM      = 0x00004000;
        private static final int SYNTHETIC = 0x00001000;
    
        private static native void registerNatives();
        static {
            registerNatives();
        }
    
        /*
         * Private constructor. Only the Java Virtual Machine creates Class objects.(私有构造,只能由JVM创建该类)
         * This constructor is not used and prevents the default constructor being
         * generated.
         */
        private Class(ClassLoader loader) {
            // Initialize final field for classLoader.  The initialization value of non-null
            // prevents future JIT optimizations from assuming this final field is null.
            classLoader = loader;
        }

    Class类被创建后的对象就是Class对象,注意,Class对象表示的是自己手动编写类的类型信息,比如创建一个Shapes类,那么,JVM就会创建一个Shapes对应Class类的Class对象,该Class对象保存了Shapes类相关的类型信息。实际上在Java中每个类都有一个Class对象,每当我们编写并且编译一个新创建的类就会产生一个对应Class对象并且这个Class对象会被保存在同名.class文件里(编译后的字节码文件保存的就是Class对象),那为什么需要这样一个Class对象呢?是这样的,当我们new一个新对象或者引用静态成员变量时,Java虚拟机(JVM)中的类加载器子系统会将对应Class对象加载到JVM中,然后JVM再根据这个类型信息相关的Class对象创建我们需要实例对象或者提供静态变量的引用值。需要特别注意的是,手动编写的每个class类,无论创建多少个实例对象,在JVM中都只有一个Class对象,即在内存中每个类有且只有一个相对应的Class对象,挺拗口,通过下图理解(内存中的简易现象图):

    到这我们也就可以得出以下几点信息:

    • Class类也是类的一种,与class关键字是不一样的。

    • 手动编写的类被编译后会产生一个Class对象,其表示的是创建的类的类型信息,而且这个Class对象保存在同名.class的文件中(字节码文件),比如创建一个Shapes类,编译Shapes类后就会创建其包含Shapes类相关类型信息的Class对象,并保存在Shapes.class字节码文件中。

    • 每个通过关键字class标识的类,在内存中有且只有一个与之对应的Class对象来描述其类型信息,无论创建多少个实例对象,其依据的都是用一个Class对象。

    • Class类只存私有构造函数,因此对应Class对象只能有JVM创建和加载

    • Class类的对象作用是运行时提供或获得某个对象的类型信息,这点对于反射技术很重要(关于反射稍后分析)。

    Class对象的加载及其获取方式

    Class对象的加载

    前面我们已提到过,Class对象是由JVM加载的,那么其加载时机是?实际上所有的类都是在对其第一次使用时动态加载到JVM中的,当程序创建第一个对类的静态成员引用时,就会加载这个被使用的类(实际上加载的就是这个类的字节码文件),注意,使用new操作符创建类的新实例对象也会被当作对类的静态成员的引用(构造函数也是类的静态方法),由此看来Java程序在它们开始运行之前并非被完全加载到内存的,其各个部分是按需加载,所以在使用该类时,类加载器首先会检查这个类的Class对象是否已被加载(类的实例对象创建时依据Class对象中类型信息完成的),如果还没有加载,默认的类加载器就会先根据类名查找.class文件(编译后Class对象被保存在同名的.class文件中),在这个类的字节码文件被加载时,它们必须接受相关验证,以确保其没有被破坏并且不包含不良Java代码(这是java的安全机制检测),完全没有问题后就会被动态加载到内存中,此时相当于Class对象也就被载入内存了(毕竟.class字节码文件保存的就是Class对象),同时也就可以被用来创建这个类的所有实例对象。下面通过一个简单例子来说明Class对象被加载的时机问题(例子引用自Thinking in Java):

    package com.zejian;
    
    class Candy {
      static {   System.out.println("Loading Candy"); }
    }
    
    class Gum {
      static {   System.out.println("Loading Gum"); }
    }
    
    class Cookie {
      static {   System.out.println("Loading Cookie"); }
    }
    
    public class SweetShop {
      public static void print(Object obj) {
        System.out.println(obj);
      }
      public static void main(String[] args) {  
        print("inside main");
        new Candy();
        print("After creating Candy");
        try {
          Class.forName("com.zejian.Gum");
        } catch(ClassNotFoundException e) {
          print("Couldn't find Gum");
        }
        print("After Class.forName(\"com.zejian.Gum\")");
        new Cookie();
        print("After creating Cookie");
      }
    }

    在上述代码中,每个类Candy、Gum、Cookie都存在一个static语句,这个语句会在类第一次被加载时执行,这个语句的作用就是告诉我们该类在什么时候被加载,执行结果:

    inside main
    Loading Candy
    After creating Candy
    Loading Gum
    After Class.forName("com.zejian.Gum")
    Loading Cookie
    After creating Cookie
    
    Process finished with exit code 0

    从结果来看,new一个Candy对象和Cookie对象,构造函数将被调用,属于静态方法的引用,Candy类的Class对象和Cookie的Class对象肯定会被加载,毕竟Candy实例对象的创建依据其Class对象。比较有意思的是

    Class.forName("com.zejian.Gum");

    其中forName方法是Class类的一个static成员方法,记住所有的Class对象都源于这个Class类,因此Class类中定义的方法将适应所有Class对象。这里通过forName方法,我们可以获取到Gum类对应的Class对象引用。从打印结果来看,调用forName方法将会导致Gum类被加载(前提是Gum类从来没有被加载过)。

    Class.forName方法

    通过上述的案例,我们也就知道Class.forName()方法的调用将会返回一个对应类的Class对象,因此如果我们想获取一个类的运行时类型信息并加以使用时,可以调用Class.forName()方法获取Class对象的引用,这样做的好处是无需通过持有该类的实例对象引用而去获取Class对象,如下的第2种方式是通过一个实例对象获取一个类的Class对象,其中的getClass()是从顶级类Object继承而来的,它将返回表示该对象的实际类型的Class对象引用。

    public static void main(String[] args) {
    
        try{
          //通过Class.forName获取Gum类的Class对象
          Class clazz=Class.forName("com.zejian.Gum");
          System.out.println("forName=clazz:"+clazz.getName());
        }catch (ClassNotFoundException e){
          e.printStackTrace();
        }
    
        //通过实例对象获取Gum的Class对象
        Gum gum = new Gum();
        Class clazz2=gum.getClass();
        System.out.println("new=clazz2:"+clazz2.getName());
    
      }

    注意调用forName方法时需要捕获一个名称为ClassNotFoundException的异常,因为forName方法在编译器是无法检测到其传递的字符串对应的类是否存在的,只能在程序运行时进行检查,如果不存在就会抛出ClassNotFoundException异常。

    Class字面常量

    在Java中存在另一种方式来生成Class对象的引用,它就是Class字面常量,如下:

    //字面常量的方式获取Class对象
    Class clazz = Gum.class;

    这种方式相对前面两种方法更加简单,更安全。因为它在编译器就会受到编译器的检查同时由于无需调用forName方法效率也会更高,因为通过字面量的方法获取Class对象的引用不会自动初始化该类。更加有趣的是字面常量的获取Class对象引用方式不仅可以应用于普通的类,也可以应用用接口,数组以及基本数据类型,这点在反射技术应用传递参数时很有帮助,关于反射技术稍后会分析,由于基本数据类型还有对应的基本包装类型,其包装类型有一个标准字段TYPE,而这个TYPE就是一个引用,指向基本数据类型的Class对象,其等价转换如下,一般情况下更倾向使用.class的形式,这样可以保持与普通类的形式统一。

    boolean.class = Boolean.TYPE;
    char.class = Character.TYPE;
    byte.class = Byte.TYPE;
    short.class = Short.TYPE;
    int.class = Integer.TYPE;
    long.class = Long.TYPE;
    float.class = Float.TYPE;
    double.class = Double.TYPE;
    void.class = Void.TYPE;

    前面提到过,使用字面常量的方式获取Class对象的引用不会触发类的初始化,这里我们可能需要简单了解一下类加载的过程,如下:

    • 加载:类加载过程的一个阶段:通过一个类的完全限定查找此类字节码文件,并利用字节码文件创建一个Class对象

    • 链接:验证字节码的安全性和完整性,准备阶段正式为静态域分配存储空间,注意此时只是分配静态成员变量的存储空间,不包含实例成员变量,如果必要的话,解析这个类创建的对其他类的所有引用。

    • 初始化:类加载最后阶段,若该类具有超类,则对其进行初始化,执行静态初始化器和静态初始化成员变量。

    由此可知,我们获取字面常量的Class引用时,触发的应该是加载阶段,因为在这个阶段Class对象已创建完成,获取其引用并不困难,而无需触发类的最后阶段初始化。下面通过小例子来验证这个过程:

    import java.util.*;
    
    class Initable {
      //编译期静态常量
      static final int staticFinal = 47;
      //非编期静态常量
      static final int staticFinal2 =
        ClassInitialization.rand.nextInt(1000);
      static {
        System.out.println("Initializing Initable");
      }
    }
    
    class Initable2 {
      //静态成员变量
      static int staticNonFinal = 147;
      static {
        System.out.println("Initializing Initable2");
      }
    }
    
    class Initable3 {
      //静态成员变量
      static int staticNonFinal = 74;
      static {
        System.out.println("Initializing Initable3");
      }
    }
    
    public class ClassInitialization {
      public static Random rand = new Random(47);
      public static void main(String[] args) throws Exception {
        //字面常量获取方式获取Class对象
        Class initable = Initable.class;
        System.out.println("After creating Initable ref");
        //不触发类初始化
        System.out.println(Initable.staticFinal);
        //会触发类初始化
        System.out.println(Initable.staticFinal2);
        //会触发类初始化
        System.out.println(Initable2.staticNonFinal);
        //forName方法获取Class对象
        Class initable3 = Class.forName("Initable3");
        System.out.println("After creating Initable3 ref");
        System.out.println(Initable3.staticNonFinal);
      }
    }

    执行结果:

    After creating Initable ref
    47
    Initializing Initable
    258
    Initializing Initable2
    147
    Initializing Initable3
    After creating Initable3 ref
    74

    从输出结果来看,可以发现,通过字面常量获取方式获取Initable类的Class对象并没有触发Initable类的初始化,这点也验证了前面的分析,同时发现调用Initable.staticFinal变量时也没有触发初始化,这是因为staticFinal属于编译期静态常量,在编译阶段通过常量传播优化的方式将Initable类的常量staticFinal存储到了一个称为NotInitialization类的常量池中,在以后对Initable类常量staticFinal的引用实际都转化为对NotInitialization类对自身常量池的引用,所以在编译期后,对编译期常量的引用都将在NotInitialization类的常量池获取,这也就是引用编译期静态常量不会触发Initable类初始化的重要原因。但在之后调用了Initable.staticFinal2变量后就触发了Initable类的初始化,注意staticFinal2虽然被static和final修饰,但其值在编译期并不能确定,因此staticFinal2并不是编译期常量,使用该变量必须先初始化Initable类。Initable2和Initable3类中都是静态成员变量并非编译期常量,引用都会触发初始化。至于forName方法获取Class对象,肯定会触发初始化,这点在前面已分析过。到这几种获取Class对象的方式也都分析完,ok~,到此这里可以得出小结论:

    • 获取Class对象引用的方式3种,通过继承自Object类的getClass方法,Class类的静态方法forName以及字面常量的方式”.class”。

    • 其中实例类的getClass方法和Class类的静态方法forName都将会触发类的初始化阶段,而字面常量获取Class对象的方式则不会触发初始化。

    • 初始化是类加载的最后一个阶段,也就是说完成这个阶段后类也就加载到内存中(Class对象在加载阶段已被创建),此时可以对类进行各种必要的操作了(如new对象,调用静态成员等),注意在这个阶段,才真正开始执行类中定义的Java程序代码或者字节码。

    关于类加载的初始化阶段,在虚拟机规范严格规定了有且只有5种场景必须对类进行初始化

    • 使用new关键字实例化对象时、读取或者设置一个类的静态字段(不包含编译期常量)以及调用静态方法的时候,必须触发类加载的初始化过程(类加载过程最终阶段)。

    • 使用反射包(java.lang.reflect)的方法对类进行反射调用时,如果类还没有被初始化,则需先进行初始化,这点对反射很重要。

    • 当初始化一个类的时候,如果其父类还没进行初始化则需先触发其父类的初始化。

    • 当Java虚拟机启动时,用户需要指定一个要执行的主类(包含main方法的类),虚拟机会先初始化这个主类

    • 当使用JDK 1.7 的动态语言支持时,如果一个java.lang.invoke.MethodHandle 实例最后解析结果为REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄,并且这个方法句柄对应类没有初始化时,必须触发其初始化(这点看不懂就算了,这是1.7的新增的动态语言支持,其关键特征是它的类型检查的主体过程是在运行期而不是编译期进行的,这是一个比较大点的话题,这里暂且打住)

    理解泛化的Class对象引用

    由于Class的引用总数指向某个类的Class对象,利用Class对象可以创建实例类,这也就足以说明Class对象的引用指向的对象确切的类型。在Java SE5引入泛型后,使用我们可以利用泛型来表示Class对象更具体的类型,即使在运行期间会被擦除,但编译期足以确保我们使用正确的对象类型。如下:

    /**
     * Created by zejian on 2017/4/30.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ClazzDemo {
    
        public static void main(String[] args){
            //没有泛型
            Class intClass = int.class;
    
            //带泛型的Class对象
            Class<Integer> integerClass = int.class;
    
            integerClass = Integer.class;
    
            //没有泛型的约束,可以随意赋值
            intClass= double.class;
    
            //编译期错误,无法编译通过
            //integerClass = double.class
        }
    }
    

    从代码可以看出,声明普通的Class对象,在编译器并不会检查Class对象的确切类型是否符合要求,如果存在错误只有在运行时才得以暴露出来。但是通过泛型声明指明类型的Class对象,编译器在编译期将对带泛型的类进行额外的类型检查,确保在编译期就能保证类型的正确性,实际上Integer.class就是一个Class<Integer>类的对象。面对下述语句,确实可能令人困惑,但该语句确实是无法编译通过的。

    //编译无法通过
    Class<Number> numberClass=Integer.class;

    我们或许会想Integer不就是Number的子类吗?然而事实并非这般简单,毕竟Integer的Class对象并非Number的Class对象的子类,前面提到过,所有的Class对象都只来源于Class类,看来事实确实如此。当然我们可以利用通配符“?”来解决问题:

    Class<?> intClass = int.class;
    intClass = double.class;

    这样的语句并没有什么问题,毕竟通配符指明所有类型都适用,那么为什么不直接使用Class还要使用Class<?>呢?这样做的好处是告诉编译器,我们是确实是采用任意类型的泛型,而非忘记使用泛型约束,因此Class<?>总是优于直接使用Class,至少前者在编译器检查时不会产生警告信息。当然我们还可以使用extends关键字告诉编译器接收某个类型的子类,如解决前面Number与Integer的问题:

    //编译通过!
    Class<? extends Number> clazz = Integer.class;
    //赋予其他类型
    clazz = double.class;
    clazz = Number.class;

    上述的代码是行得通的,extends关键字的作用是告诉编译器,只要是Number的子类都可以赋值。这点与前面直接使用Class<Number>是不一样的。实际上,应该时刻记住向Class引用添加泛型约束仅仅是为了提供编译期类型的检查从而避免将错误延续到运行时期。

    关于类型转换的问题

    在许多需要强制类型转换的场景,我们更多的做法是直接强制转换类型:

    package com.zejian;
    
    /**
     * Created by zejian on 2017/4/30.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ClassCast {
    
     public void cast(){
    
         Animal animal= new Dog();
         //强制转换
         Dog dog = (Dog) animal;
     }
    }
    
    interface Animal{ }
    
    class Dog implements  Animal{ }

    之所可以强制转换,这得归功于RRTI,要知道在Java中,所有类型转换都是在运行时进行正确性检查的,利用RRTI进行判断类型是否正确从而确保强制转换的完成,如果类型转换失败,将会抛出类型转换异常。除了强制转换外,在Java SE5中新增一种使用Class对象进行类型转换的方式,如下:

    Animal animal= new Dog();
    //这两句等同于Dog dog = (Dog) animal;
    Class<Dog> dogType = Dog.class;
    Dog dog = dogType.cast(animal)

    利用Class对象的cast方法,其参数接收一个参数对象并将其转换为Class引用的类型。这种方式似乎比之前的强制转换更麻烦些,确实如此,而且当类型不能正确转换时,仍然会抛出ClassCastException异常。源码如下:

    public T cast(Object obj) {
        if (obj != null && !isInstance(obj))
             throw new ClassCastException(cannotCastMsg(obj));
         return (T) obj;
      }

    instanceof 关键字与isInstance方法

    关于instanceof 关键字,它返回一个boolean类型的值,意在告诉我们对象是不是某个特定的类型实例。如下,在强制转换前利用instanceof检测obj是不是Animal类型的实例对象,如果返回true再进行类型转换,这样可以避免抛出类型转换的异常(ClassCastException)

    public void cast2(Object obj){
        if(obj instanceof Animal){
              Animal animal= (Animal) obj;
          }
    }

    而isInstance方法则是Class类中的一个Native方法,也是用于判断对象类型的,看个简单例子:

    public void cast2(Object obj){
            //instanceof关键字
            if(obj instanceof Animal){
                Animal animal= (Animal) obj;
            }
    
            //isInstance方法
            if(Animal.class.isInstance(obj)){
                Animal animal= (Animal) obj;
            }
      }

    事实上instanceOf 与isInstance方法产生的结果是相同的。对于instanceOf是关键字只被用于对象引用变量,检查左边对象是不是右边类或接口的实例化。如果被测对象是null值,则测试结果总是false。一般形式:

    //判断这个对象是不是这种类型
    obj.instanceof(class)

    而isInstance方法则是Class类的Native方法,其中obj是被测试的对象或者变量,如果obj是调用这个方法的class或接口的实例,则返回true。如果被检测的对象是null或者基本类型,那么返回值是false;一般形式如下:

    //判断这个对象能不能被转化为这个类
    class.inInstance(obj)

    最后这里给出一个简单实例,验证isInstance方法与instanceof等价性:

    class A {}
    
    class B extends A {}
    
    public class C {
      static void test(Object x) {
        print("Testing x of type " + x.getClass());
        print("x instanceof A " + (x instanceof A));
        print("x instanceof B "+ (x instanceof B));
        print("A.isInstance(x) "+ A.class.isInstance(x));
        print("B.isInstance(x) " +
          B.class.isInstance(x));
        print("x.getClass() == A.class " +
          (x.getClass() == A.class));
        print("x.getClass() == B.class " +
          (x.getClass() == B.class));
        print("x.getClass().equals(A.class)) "+
          (x.getClass().equals(A.class)));
        print("x.getClass().equals(B.class)) " +
          (x.getClass().equals(B.class)));
      }
      public static void main(String[] args) {
        test(new A());
        test(new B());
      } 
    }

    执行结果:

    Testing x of type class com.zejian.A
    x instanceof A true
    x instanceof B false //父类不一定是子类的某个类型
    A.isInstance(x) true
    B.isInstance(x) false
    x.getClass() == A.class true
    x.getClass() == B.class false
    x.getClass().equals(A.class)) true
    x.getClass().equals(B.class)) false
    ---------------------------------------------
    Testing x of type class com.zejian.B
    x instanceof A true
    x instanceof B true
    A.isInstance(x) true
    B.isInstance(x) true
    x.getClass() == A.class false
    x.getClass() == B.class true
    x.getClass().equals(A.class)) false
    x.getClass().equals(B.class)) true

    到此关于Class对象相关的知识点都分析完了,下面将结合Class对象的知识点分析反射技术。

    理解反射技术

    反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性,这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。一直以来反射技术都是Java中的闪亮点,这也是目前大部分框架(如Spring/Mybatis等)得以实现的支柱。在Java中,Class类与java.lang.reflect类库一起对反射技术进行了全力的支持。在反射包中,我们常用的类主要有Constructor类表示的是Class 对象所表示的类的构造方法,利用它可以在运行时动态创建对象、Field表示Class对象所表示的类的成员变量,通过它可以在运行时动态修改成员变量的属性值(包含private)、Method表示Class对象所表示的类的成员方法,通过它可以动态调用对象的方法(包含private),下面将对这几个重要类进行分别说明。

    Constructor类及其用法

    Constructor类存在于反射包(java.lang.reflect)中,反映的是Class 对象所表示的类的构造方法。获取Constructor对象是通过Class类中的方法获取的,Class类与Constructor相关的主要方法如下:

    方法返回值 方法名称 方法说明
    static Class<?> forName(String className) 返回与带有给定字符串名的类或接口相关联的 Class 对象。
    Constructor<T> getConstructor(Class<?>... parameterTypes) 返回指定参数类型、具有public访问权限的构造函数对象
    Constructor<?>[] getConstructors() 返回所有具有public访问权限的构造函数的Constructor对象数组
    Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 返回指定参数类型、所有声明的(包括private)构造函数对象
    Constructor<?>[] getDeclaredConstructor() 返回所有声明的(包括private)构造函数对象
    T newInstance() 创建此 Class 对象所表示的类的一个新实例。

    下面看一个简单例子来了解Constructor对象的使用:

    package reflect;
    
    import java.io.Serializable;
    import java.lang.reflect.Constructor;
    
    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectDemo implements Serializable{
        public static void main(String[] args) throws Exception {
    
            Class<?> clazz = null;
    
            //获取Class对象的引用
            clazz = Class.forName("reflect.User");
    
            //第一种方法,实例化默认构造方法,User必须无参构造函数,否则将抛异常
            User user = (User) clazz.newInstance();
            user.setAge(20);
            user.setName("Rollen");
            System.out.println(user);
    
            System.out.println("--------------------------------------------");
    
            //获取带String参数的public构造函数
            Constructor cs1 =clazz.getConstructor(String.class);
            //创建User
            User user1= (User) cs1.newInstance("xiaolong");
            user1.setAge(22);
            System.out.println("user1:"+user1.toString());
    
            System.out.println("--------------------------------------------");
    
            //取得指定带int和String参数构造函数,该方法是私有构造private
            Constructor cs2=clazz.getDeclaredConstructor(int.class,String.class);
            //由于是private必须设置可访问
            cs2.setAccessible(true);
            //创建user对象
            User user2= (User) cs2.newInstance(25,"lidakang");
            System.out.println("user2:"+user2.toString());
    
            System.out.println("--------------------------------------------");
    
            //获取所有构造包含private
            Constructor<?> cons[] = clazz.getDeclaredConstructors();
            // 查看每个构造方法需要的参数
            for (int i = 0; i < cons.length; i++) {
                //获取构造函数参数类型
                Class<?> clazzs[] = cons[i].getParameterTypes();
                System.out.println("构造函数["+i+"]:"+cons[i].toString() );
                System.out.print("参数类型["+i+"]:(");
                for (int j = 0; j < clazzs.length; j++) {
                    if (j == clazzs.length - 1)
                        System.out.print(clazzs[j].getName());
                    else
                        System.out.print(clazzs[j].getName() + ",");
                }
                System.out.println(")");
            }
        }
    }
    
    
    class User {
        private int age;
        private String name;
        public User() {
            super();
        }
        public User(String name) {
            super();
            this.name = name;
        }
    
        /**
         * 私有构造
         * @param age
         * @param name
         */
        private User(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
    
      //..........省略set 和 get方法
    }

    运行结果:

    User [age=20, name=Rollen]
    --------------------------------------------
    user1:User [age=22, name=xiaolong]
    --------------------------------------------
    user2:User [age=25, name=lidakang]
    --------------------------------------------
    构造函数[0]:private reflect.User(int,java.lang.String)
    参数类型[0]:(int,java.lang.String)
    构造函数[1]:public reflect.User(java.lang.String)
    参数类型[1]:(java.lang.String)
    构造函数[2]:public reflect.User()
    参数类型[2]:()

    关于Constructor类本身一些常用方法如下(仅部分,其他可查API),

    方法返回值 方法名称 方法说明
    Class<T> getDeclaringClass() 返回 Class 对象,该对象表示声明由此 Constructor 对象表示的构造方法的类,其实就是返回真实类型(不包含参数)
    Type[] getGenericParameterTypes() 按照声明顺序返回一组 Type 对象,返回的就是 Constructor对象构造函数的形参类型。
    String getName() 以字符串形式返回此构造方法的名称。
    Class<?>[] getParameterTypes() 按照声明顺序返回一组 Class 对象,即返回Constructor 对象所表示构造方法的形参类型
    T newInstance(Object... initargs) 使用此 Constructor对象表示的构造函数来创建新实例
    String toGenericString() 返回描述此 Constructor 的字符串,其中包括类型参数。

    代码演示如下:

    Constructor cs3=clazz.getDeclaredConstructor(int.class,String.class);
    
    System.out.println("-----getDeclaringClass-----");
    Class uclazz=cs3.getDeclaringClass();
    //Constructor对象表示的构造方法的类
    System.out.println("构造方法的类:"+uclazz.getName());
    
    System.out.println("-----getGenericParameterTypes-----");
    //对象表示此 Constructor 对象所表示的方法的形参类型
    Type[] tps=cs3.getGenericParameterTypes();
    for (Type tp:tps) {
        System.out.println("参数名称tp:"+tp);
    }
    System.out.println("-----getParameterTypes-----");
    //获取构造函数参数类型
    Class<?> clazzs[] = cs3.getParameterTypes();
    for (Class claz:clazzs) {
        System.out.println("参数名称:"+claz.getName());
    }
    System.out.println("-----getName-----");
    //以字符串形式返回此构造方法的名称
    System.out.println("getName:"+cs3.getName());
    
    System.out.println("-----getoGenericString-----");
    //返回描述此 Constructor 的字符串,其中包括类型参数。
    System.out.println("getoGenericString():"+cs3.toGenericString());
    /**
     输出结果:
     -----getDeclaringClass-----
     构造方法的类:reflect.User
     -----getGenericParameterTypes-----
     参数名称tp:int
     参数名称tp:class java.lang.String
     -----getParameterTypes-----
     参数名称:int
     参数名称:java.lang.String
     -----getName-----
     getName:reflect.User
     -----getoGenericString-----
     getoGenericString():private reflect.User(int,java.lang.String)
     */

    其中关于Type类型这里简单说明一下,Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。getGenericParameterTypesgetParameterTypes 都是获取构成函数的参数类型,前者返回的是Type类型,后者返回的是Class类型,由于Type顶级接口,Class也实现了该接口,因此Class类是Type的子类,Type 表示的全部类型而每个Class对象表示一个具体类型的实例,如String.class仅代表String类型。由此看来Type与 Class 表示类型几乎是相同的,只不过 Type表示的范围比Class要广得多而已。当然Type还有其他子类,如:

    • TypeVariable:表示类型参数,可以有上界,比如:T extends Number

    • ParameterizedType:表示参数化的类型,有原始类型和具体的类型参数,比如:List<String>

    • WildcardType:表示通配符类型,比如:?, ? extends Number, ? super Integer

    通过以上的分析,对于Constructor类已有比较清晰的理解,利用好Class类和Constructor类,我们可以在运行时动态创建任意对象,从而突破必须在编译期知道确切类型的障碍。

    Field类及其用法

    Field 提供有关类或接口的单个字段的信息,以及对它的动态访问权限。反射的字段可能是一个类(静态)字段或实例字段。同样的道理,我们可以通过Class类的提供的方法来获取代表字段信息的Field对象,Class类与Field对象相关方法如下:

    方法返回值 方法名称 方法说明
    Field getDeclaredField(String name) 获取指定name名称的(包含private修饰的)字段,不包括继承的字段
    Field[] getDeclaredField() 获取Class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段
    Field getField(String name) 获取指定name名称、具有public修饰的字段,包含继承字段
    Field[] getField() 获取修饰符为public的字段,包含继承字段

     
    下面的代码演示了上述方法的使用过程

    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectField {
    
        public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
            Class<?> clazz = Class.forName("reflect.Student");
            //获取指定字段名称的Field类,注意字段修饰符必须为public而且存在该字段,
            // 否则抛NoSuchFieldException
            Field field = clazz.getField("age");
            System.out.println("field:"+field);
    
            //获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取
            Field fields[] = clazz.getFields();
            for (Field f:fields) {
                System.out.println("f:"+f.getDeclaringClass());
            }
    
            System.out.println("================getDeclaredFields====================");
            //获取当前类所字段(包含private字段),注意不包含父类的字段
            Field fields2[] = clazz.getDeclaredFields();
            for (Field f:fields2) {
                System.out.println("f2:"+f.getDeclaringClass());
            }
            //获取指定字段名称的Field类,可以是任意修饰符的自动,注意不包含父类的字段
            Field field2 = clazz.getDeclaredField("desc");
            System.out.println("field2:"+field2);
        }
        /**
          输出结果: 
         field:public int reflect.Person.age
         f:public java.lang.String reflect.Student.desc
         f:public int reflect.Person.age
         f:public java.lang.String reflect.Person.name
    
         ================getDeclaredFields====================
         f2:public java.lang.String reflect.Student.desc
         f2:private int reflect.Student.score
         field2:public java.lang.String reflect.Student.desc
         */
    }
    
    class Person{
        public int age;
        public String name;
        //省略set和get方法
    }
    
    class Student extends Person{
        public String desc;
        private int score;
        //省略set和get方法
    }

    上述方法需要注意的是,如果我们不期望获取其父类的字段,则需使用Class类的getDeclaredField/getDeclaredFields方法来获取字段即可,倘若需要连带获取到父类的字段,那么请使用Class类的getField/getFields,但是也只能获取到public修饰的的字段,无法获取父类的私有字段。下面将通过Field类本身的方法对指定类属性赋值,代码演示如下:

    //获取Class对象引用
    Class<?> clazz = Class.forName("reflect.Student");
    
    Student st= (Student) clazz.newInstance();
    //获取父类public字段并赋值
    Field ageField = clazz.getField("age");
    ageField.set(st,18);
    Field nameField = clazz.getField("name");
    nameField.set(st,"Lily");
    
    //只获取当前类的字段,不获取父类的字段
    Field descField = clazz.getDeclaredField("desc");
    descField.set(st,"I am student");
    Field scoreField = clazz.getDeclaredField("score");
    //设置可访问,score是private的
    scoreField.setAccessible(true);
    scoreField.set(st,88);
    System.out.println(st.toString());
    
    //输出结果:Student{age=18, name='Lily ,desc='I am student', score=88} 
    
    //获取字段值
    System.out.println(scoreField.get(st));
    // 88

    其中的set(Object obj, Object value)方法是Field类本身的方法,用于设置字段的值,而get(Object obj)则是获取字段的值,当然关于Field类还有其他常用的方法如下:

    方法返回值 方法名称 方法说明
    void set(Object obj, Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
    Object get(Object obj) 返回指定对象上此 Field 表示的字段的值
    Class<?> getType() 返回一个 Class 对象,它标识了此Field 对象所表示字段的声明类型。
    boolean isEnumConstant() 如果此字段表示枚举类型的元素则返回 true;否则返回 false
    String toGenericString() 返回一个描述此 Field(包括其一般类型)的字符串
    String getName() 返回此 Field 对象表示的字段的名称
    Class<?> getDeclaringClass() 返回表示类或接口的 Class 对象,该类或接口声明由此 Field 对象表示的字段
    void setAccessible(boolean flag) 将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性

     
    上述方法可能是较为常用的,事实上在设置值的方法上,Field类还提供了专门针对基本数据类型的方法,如setInt()/getInt()、setBoolean()/getBoolean、setChar()/getChar()等等方法,这里就不全部列出了,需要时查API文档即可。需要特别注意的是被final关键字修饰的Field字段是安全的,在运行时可以接收任何修改,但最终其实际值是不会发生改变的。

    Method类及其用法

    Method 提供关于类或接口上单独某个方法(以及如何访问该方法)的信息,所反映的方法可能是类方法或实例方法(包括抽象方法)。下面是Class类获取Method对象相关的方法:

    方法返回值 方法名称 方法说明
    Method getDeclaredMethod(String name, Class<?>... parameterTypes) 返回一个指定参数的Method对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
    Method[] getDeclaredMethod() 返回 Method 对象的一个数组,这些对象反映此 Class 对象表示的类或接口声明的所有方法,包括公共、保护、默认(包)访问和私有方法,但不包括继承的方法。
    Method getMethod(String name, Class<?>... parameterTypes) 返回一个 Method 对象,它反映此 Class 对象所表示的类或接口的指定公共成员方法。
    Method[] getMethods() 返回一个包含某些 Method 对象的数组,这些对象反映此 Class 对象所表示的类或接口(包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口)的公共 member 方法。

    同样通过案例演示上述方法:

    import java.lang.reflect.Method;
    
    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectMethod  {
    
    
        public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
    
            Class clazz = Class.forName("reflect.Circle");
    
            //根据参数获取public的Method,包含继承自父类的方法
            Method method = clazz.getMethod("draw",int.class,String.class);
    
            System.out.println("method:"+method);
    
            //获取所有public的方法:
            Method[] methods =clazz.getMethods();
            for (Method m:methods){
                System.out.println("m::"+m);
            }
    
            System.out.println("=========================================");
    
            //获取当前类的方法包含private,该方法无法获取继承自父类的method
            Method method1 = clazz.getDeclaredMethod("drawCircle");
            System.out.println("method1::"+method1);
            //获取当前类的所有方法包含private,该方法无法获取继承自父类的method
            Method[] methods1=clazz.getDeclaredMethods();
            for (Method m:methods1){
                System.out.println("m1::"+m);
            }
        }
    
    /**
         输出结果:
         method:public void reflect.Shape.draw(int,java.lang.String)
    
         m::public int reflect.Circle.getAllCount()
         m::public void reflect.Shape.draw()
         m::public void reflect.Shape.draw(int,java.lang.String)
         m::public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
         m::public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
         m::public final void java.lang.Object.wait() throws java.lang.InterruptedException
         m::public boolean java.lang.Object.equals(java.lang.Object)
         m::public java.lang.String java.lang.Object.toString()
         m::public native int java.lang.Object.hashCode()
         m::public final native java.lang.Class java.lang.Object.getClass()
         m::public final native void java.lang.Object.notify()
         m::public final native void java.lang.Object.notifyAll()
    
         =========================================
         method1::private void reflect.Circle.drawCircle()
    
         m1::public int reflect.Circle.getAllCount()
         m1::private void reflect.Circle.drawCircle()
         */
    }
    
    class Shape {
        public void draw(){
            System.out.println("draw");
        }
    
        public void draw(int count , String name){
            System.out.println("draw "+ name +",count="+count);
        }
    
    }
    class Circle extends Shape{
    
        private void drawCircle(){
            System.out.println("drawCircle");
        }
        public int getAllCount(){
            return 100;
        }
    }

    在通过getMethods方法获取Method对象时,会把父类的方法也获取到,如上的输出结果,把Object类的方法都打印出来了。而getDeclaredMethod/getDeclaredMethods方法都只能获取当前类的方法。我们在使用时根据情况选择即可。下面将演示通过Method对象调用指定类的方法:

    Class clazz = Class.forName("reflect.Circle");
    //创建对象
    Circle circle = (Circle) clazz.newInstance();
    
    //获取指定参数的方法对象Method
    Method method = clazz.getMethod("draw",int.class,String.class);
    
    //通过Method对象的invoke(Object obj,Object... args)方法调用
    method.invoke(circle,15,"圈圈");
    
    //对私有无参方法的操作
    Method method1 = clazz.getDeclaredMethod("drawCircle");
    //修改私有方法的访问标识
    method1.setAccessible(true);
    method1.invoke(circle);
    
    //对有返回值得方法操作
    Method method2 =clazz.getDeclaredMethod("getAllCount");
    Integer count = (Integer) method2.invoke(circle);
    System.out.println("count:"+count);
    
    /**
        输出结果:
        draw 圈圈,count=15
        drawCircle
        count:100
    */

    在上述代码中调用方法,使用了Method类的invoke(Object obj,Object... args)第一个参数代表调用的对象,第二个参数传递的调用方法的参数。这样就完成了类方法的动态调用。

    方法返回值 方法名称 方法说明
    Object invoke(Object obj, Object... args) 对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。
    Class<?> getReturnType() 返回一个 Class 对象,该对象描述了此 Method 对象所表示的方法的正式返回类型,即方法的返回类型
    Type getGenericReturnType() 返回表示由此 Method 对象所表示方法的正式返回类型的 Type 对象,也是方法的返回类型。
    Class<?>[] getParameterTypes() 按照声明顺序返回 Class 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组
    Type[] getGenericParameterTypes() 按照声明顺序返回 Type 对象的数组,这些对象描述了此 Method 对象所表示的方法的形参类型的,也是返回方法的参数类型
    String getName() 以 String 形式返回此 Method 对象表示的方法名称,即返回方法的名称
    boolean isVarArgs() 判断方法是否带可变参数,如果将此方法声明为带有可变数量的参数,则返回 true;否则,返回 false。
    String toGenericString() 返回描述此 Method 的字符串,包括类型参数。

     
    getReturnType方法/getGenericReturnType方法都是获取Method对象表示的方法的返回类型,只不过前者返回的Class类型后者返回的Type(前面已分析过),Type就是一个接口而已,在Java8中新增一个默认的方法实现,返回的就参数类型信息

    public interface Type {
        //1.8新增
        default String getTypeName() {
            return toString();
        }
    }

    而getParameterTypes/getGenericParameterTypes也是同样的道理,都是获取Method对象所表示的方法的参数类型,其他方法与前面的Field和Constructor是类似的。

    反射包中的Array类

    在Java的java.lang.reflect包中存在着一个可以动态操作数组的类,Array,它提供了动态创建和访问 Java 数组的方法。Array 允许在执行 get 或 set 操作进行取值和赋值。在Class类中与数组关联的方法是:

    方法返回值 方法名称 方法说明
    Class<?> getComponentType() 返回表示数组元素类型的 Class,即数组的类型
    boolean isArray() 判定此 Class 对象是否表示一个数组类。

    java.lang.reflect.Array中的常用静态方法如下:

    方法返回值 方法名称 方法说明
    static Object set(Object array, int index) 返回指定数组对象中索引组件的值。
    static int getLength(Object array) 以 int 形式返回指定数组对象的长度
    static object newInstance(Class<?> componentType, int... dimensions) 创建一个具有指定类型和维度的新数组。
    static Object newInstance(Class<?> componentType, int length) 创建一个具有指定的组件类型和长度的新数组。
    static void set(Object array, int index, Object value) 将指定数组对象中索引组件的值设置为指定的新值。

    下面通过一个简单例子来演示这些方法

    package reflect;
    
    import java.lang.reflect.Array;
    
    /**
     * Created by zejian on 2017/5/1.
     * Blog : http://blog.csdn.net/javazejian [原文地址,请尊重原创]
     */
    public class ReflectArray {
    
        public static void main(String[] args) throws ClassNotFoundException {
            int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            //获取数组类型的Class 即int.class
            Class<?> clazz = array.getClass().getComponentType();
            //创建一个具有指定的组件类型和长度的新数组。
            //第一个参数:数组的类型,第二个参数:数组的长度
            Object newArr = Array.newInstance(clazz, 15);
            //获取原数组的长度
            int co = Array.getLength(array);
            //赋值原数组到新数组
            System.arraycopy(array, 0, newArr, 0, co);
            for (int i:(int[]) newArr) {
                System.out.print(i+",");
            }
    
            //创建了一个长度为10 的字符串数组,
            //接着把索引位置为6 的元素设为"hello world!",然后再读取索引位置为6 的元素的值
            Class clazz2 = Class.forName("java.lang.String");
    
            //创建一个长度为10的字符串数组,在Java中数组也可以作为Object对象
            Object array2 = Array.newInstance(clazz2, 10);
    
            //把字符串数组对象的索引位置为6的元素设置为"hello"
            Array.set(array2, 6, "hello world!");
    
            //获得字符串数组对象的索引位置为5的元素的值
            String str = (String)Array.get(array2, 6);
            System.out.println();
            System.out.println(str);//hello
        }
        /**
         输出结果:
         1,2,3,4,5,6,7,8,9,0,0,0,0,0,0,
         hello world!
         */
    }

    通过上述代码演示,确实可以利用Array类和反射相结合动态创建数组,也可以在运行时动态获取和设置数组中元素的值,其实除了上的set/get外Array还专门为8种基本数据类型提供特有的方法,如setInt/getInt、setBoolean/getBoolean,其他依次类推,需要使用是可以查看API文档即可。除了上述动态修改数组长度或者动态创建数组或动态获取值或设置值外,可以利用泛型动态创建泛型数组如下:

    /**
      * 接收一个泛型数组,然后创建一个长度与接收的数组长度一样的泛型数组,
      * 并把接收的数组的元素复制到新创建的数组中,
      * 最后找出新数组中的最小元素,并打印出来
      * @param a
      * @param <T>
      */
     public  <T extends Comparable<T>> void min(T[] a) {
         //通过反射创建相同类型的数组
         T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(), a.length);
         for (int i = 0; i < a.length; i++) {
             b[i] = a[i];
         }
         T min = null;
         boolean flag = true;
         for (int i = 0; i < b.length; i++) {
             if (flag) {
                 min = b[i];
                 flag = false;
             }
             if (b[i].compareTo(min) < 0) {
                 min = b[i];
             }
         }
         System.out.println(min);
     }

    毕竟我们无法直接创建泛型数组,有了Array的动态创建数组的方式这个问题也就迎刃而解了。

    //无效语句,编译不通
    T[] a = new T[];

    ok~,到这反射中几个重要并且常用的类我们都基本介绍完了,但更重要是,我们应该认识到反射机制并没有什么神奇之处。当通过反射与一个未知类型的对象打交道时,JVM只会简单地检查这个对象,判断该对象属于那种类型,同时也应该知道,在使用反射机制创建对象前,必须确保已加载了这个类的Class对象,当然这点完全不必由我们操作,毕竟只能JVM加载,但必须确保该类的”.class”文件已存在并且JVM能够正确找到。关于Class类的方法在前面我们只是分析了主要的一些方法,其实Class类的API方法挺多的,建议查看一下API文档,浏览一遍,有个印象也是不错的选择,这里仅列出前面没有介绍过又可能用到的API:

     /** 
      *    修饰符、父类、实现的接口、注解相关 
      */
    
    //获取修饰符,返回值可通过Modifier类进行解读
    public native int getModifiers();
    //获取父类,如果为Object,父类为null
    public native Class<? super T> getSuperclass();
    //对于类,为自己声明实现的所有接口,对于接口,为直接扩展的接口,不包括通过父类间接继承来的
    public native Class<?>[] getInterfaces();
    //自己声明的注解
    public Annotation[] getDeclaredAnnotations();
    //所有的注解,包括继承得到的
    public Annotation[] getAnnotations();
    //获取或检查指定类型的注解,包括继承得到的
    public <A extends Annotation> A getAnnotation(Class<A> annotationClass);
    public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass);
    
    /** 
      *   内部类相关
      */
    //获取所有的public的内部类和接口,包括从父类继承得到的
    public Class<?>[] getClasses();
    //获取自己声明的所有的内部类和接口
    public Class<?>[] getDeclaredClasses();
    //如果当前Class为内部类,获取声明该类的最外部的Class对象
    public Class<?> getDeclaringClass();
    //如果当前Class为内部类,获取直接包含该类的类
    public Class<?> getEnclosingClass();
    //如果当前Class为本地类或匿名内部类,返回包含它的方法
    public Method getEnclosingMethod();
    
    /** 
      *    Class对象类型判断相关
      */
    //是否是数组
    public native boolean isArray();  
    //是否是基本类型
    public native boolean isPrimitive();
    //是否是接口
    public native boolean isInterface();
    //是否是枚举
    public boolean isEnum();
    //是否是注解
    public boolean isAnnotation();
    //是否是匿名内部类
    public boolean isAnonymousClass();
    //是否是成员类
    public boolean isMemberClass();
    //是否是本地类
    public boolean isLocalClass(); 

    ok~,本篇到此完结。


    展开全文
  • RTTI(Run-Time Type Identification) 运行时类型识别,最先出现在C++里,引入这机制是为了让程序在运行时能根据基类的指针或引用来获得该指针或引用所指的对象实际类型Java中的RRTI则是源于《Thinking in ...

    一、引言

    什么是RTTI

    RTTI(Run-Time Type Identification) 运行时类型识别,最先出现在C++里,引入这个机制是为了让程序在运行时能根据基类的指针或引用来获得该指针或引用所指的对象的实际类型。

    Java中的RRTI则是源于《Thinking in Java》一书,可以在程序运行时发现和使用类型信息。这使得我们从只能在编译期执行面向类型的操作中解脱出来。主要有两种方式:一是传统的RRTI,它假定我们在编译期已知道了所有类型(如new对象时必须定义好类型);但并不是所有的Class都能在编译时明确,因此在某些情况下需要在运行时再发现和确定类型信息(比如:基于构建编程),这就需要第二种方式:反射机制,它允许我们在运行时发现和使用类型的信息。

    为什么需要RTTI

    按字面意思,我们在某些时候需要知道类的信息并使用它。具体看下面这个例子,我们定义了一个基类Animal及通用行为eat(),派生出的具体类有Dog、Cat和Brid,见下图。
    在这里插入图片描述
    在面向对象编程中基本目的是:让代码只操纵对基类(这里是Animal)的引用。为了实现这点,通常我们在创建具体类的对象时,都将其向上转型为对应的父类,然后在其余的代码中都使用这个父类,这是为了方便以后扩展,例如你可以向下面这样编码:

    abstract class Animal {
    	void eat() {
    		System.out.println("吃");
    	}
    }
    
    class Dog extends Animal {
    	void eat() {
    		System.out.println("狗吃骨头");
    	}
    }
    
    class Cat extends Animal {
    	void eat() {
    		System.out.println("猫吃小鱼");
    	}
    }
    
    class Brid extends Animal {
    	void eat() {
    		System.out.println("鸟吃虫子");
    	}
    }
    
    public class AnimalTest {
    	public static void main(String[] args) {
    		List<Animal> aList = Arrays.asList(
    			new Dog(), new Cat(), new Brid() 
    		);
    		for (Animal animal : aList) {
    			animal.eat();
    		}
    	}
    }
    

    Output:

    狗吃骨头
    猫吃小鱼
    鸟吃虫子
    

    在这个例子中,创建 Dog、Cat、Brid对象放入List <Animal>中时会向上转型,同时也丢失了它们的具体类型,对于List而言,它们都是Animal类的对象。这时,假如我们需要知道某个泛化引用的确切类型,该怎么办呢?例如,我们只有骨头来喂食动物,猫和鸟并不吃骨头,怎么才能知道这个Animal对象是狗呢?或者我们想要拍动物在天空的照片,这时必须筛选出鸟类,因为其它动物不会飞。

    使用RTTI,通过它可以查询某个Animal引用所指向的对象的确切类型,然后选择你需要的或者剔除你不要的。

    二、深入理解Class对象

    Class类的概念

    想要理解RTTI在Java中的工作原理,首先得知道类型信息在运行时是如何表示的。Java用Class类来表示运行时的类型信息,首先必须明确,Class类跟Java API中定义的String、Integer等类以及我们自己定义的类是一样的,是一个实实在在的类,只不过名字特殊点,在JDK的java.lang包中。

    那么Class类到底有什么作用呢?是什么的抽象,其实例又表示什么呢?

    对于我们自己定义的类,我们用类来抽象现实中的某些事物,比如我们定义名为Dog的类来抽象现实中的狗,然后可以实例化这个类,用这些实例来表示一条黑狗、一条黄狗、我家的狗、你家的狗等等。我们还用Cat类来抽象现实中的猫,用Brid类来抽象现实中的鸟。那么,Dog、Cat、Brid这三个类之间有没有共同特征了,可不可以对这三个类进行抽象呢?

    当然可以,我们都知道所有的class都是Object的子类,都有类名,有hashcode,可以判断类型属于class、interface、enum还是annotation。另外可以定义一些方法,比如获取某个方法、获取类型名等等。这样就封装了一个表示类型的类 — Class,用来提取这些类的一些共同特征,表示对这些类(或接口)的抽象。而Dog、Cat、Brid这三个类就分别是Class类的对象。也就是说,每个类都有一个Class对象,即每当我们编写并且编译一个新类,就会产生一个对应的Class对象,被保存在一个同名.class文件(编译后的字节码文件)里。

    下面我们来分析一下Class类的源码:

    //前一个Class表示这是一个类的声明,第二个Class是类的名称,
      <T>表示这是一个泛型类,并实现了四种接口。
    public final class Class<T> implements java.io.Serializable,GenericDeclaration,Type, AnnotatedElement {
      
        //定义了三个静态变量
        private static final int ANNOTATION= 0x00002000;
        private static final int ENUM      = 0x00004000;
        private static final int SYNTHETIC = 0x00001000;
    
        //定义了一个名为registerNatives()的本地方法,并在静态块中调用:
        private static native void registerNatives();
        static {
            registerNatives();
        }
    
        // 私有构造函数,只能由JVM调用,创建该类实例
        private Class(ClassLoader loader) {
            classLoader = loader;
        }
        
        /*如果Class对象是一个Java类,返回class full_classname,即class 包名.类名;
          比如上面例子的List,返回的就是class java.util.List;
          如果是接口,将class改成interface;
          如果是void类型,则返回void;
          如果是基本类型,返回基本类型。*/
    	public String toString() {
            return (isInterface() ?"interface " : (isPrimitive() ? "" : "class")) + getName();
        }
    

    注意:Class类的构造器是private的,这意味着我们无法用new关键字得到一个Class对象。为了生成一个类的Class对象,必须通过运行Java虚拟机(JVM)中的类加载器子系统。

    从上我们可以总结出:

    • Class类的作用是运行时提供或获得某个对象的类型信息;
    • Class类也是类的一种,只是名字和class关键字高度相似;
    • Class类的对象表示你创建的类的类型信息,比如你创建一个Dog类,那么,Java编译后就会创建一个包含Dog类型信息的Class对象;
    • Class类只有私有构造函数,因此对应的Class对象不能像普通类一样,以 new 操作符的方式创建,只能通过JVM加载。
    • 一个class类有且只有一个相对应的Class对象(无论创建多少个实例对象,在JVM中都只有一个Class对象),如下图所示:
      在这里插入图片描述

    Class对象的加载

    那么JVM是如何加载这个类的?

    当程序创建第一个对类的静态成员的引用时,JVM中的类加载器子系统会将类对应的Class对象加载到JVM中。这个证明构造器也是类的静态方法,尽管构造器前并没有用static关键字修饰。因此,当我们使用new操作符创建一个类的实例对象时,也会被当作对类的静态成员的引用。

    可以看出,Java一门动态加载的语言,Java中的类在需要时才会被加载。也就是说,我们编写出的Java程序,在它们开始运行之前并非被完全加载到内存的,其各个部分是在需要时才加载。因此,在我们需要用到某个类时,类加载器首先检查这个类的Class对象是否已被加载,如果没有加载,默认的类加载器就会先根据类名查找.class文件。在这个类的字节码文件被加载时,它们要接受验证,以确保其没有被破坏、并且不包含不良Java代码(这是java众多安全检测机制中的一个),检测通过后Class对象就被载入内存了,可以被用来创建这个类的所有实例对象。下图表示了一个类加载的过程:
    在这里插入图片描述

    • 第一阶段(加载):类加载器根据类名找到此类的.Class文件,并把这个文件包含的字节码加载到内存中,生成Class对象。

    • 第二阶段(链接):又分为三个步骤,分别是:

      (1) 验证阶段:确保Class文件的字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身的安全。

      (2) 准备阶段:正式为类变量(static 成员变量)分配内存并设置类变量初始值(零值)的阶段,这些变量所使用的内存都将在方法区中进行分配。

      (3)解析阶段:虚拟机将常量池内的符号引用替换为直接引用的过程。

    • 第三阶段(初始化):类中静态属性和初始化赋值,以及静态块的执行。

    Class对象的获取方式

    Java主要提供了三种方式来获取一个实例对象对应的Class对象:

    1. Class.forName():

    这个方法是Class类的一个static成员方法。Class对象和其他对象一样,我们可以获取并操作它的引用,forName()就是取得Class对象的引用的一种方法,该方法允许我们无需通过持有该类的实例对象引用而去获取Class对象。

    	try {
    	  		//"com.yang"是包名
    	 		Class c1 = Class.forName("com.yang.Dog");
    		} 	catch (ClassNotFoundException e) {
    		         e.printStackTrace();
     	   }
    

    注意:如果Class.forName()没有找到你要加载的类,会抛出ClassNotFoundException异常。因此,在调用forName()方法时,需要向上面一样,给出一个ClassNotFoundException异常捕获。

    1. getClass():

    通过new一个对象,用这个对象调用getClass()方法来获取Class的引用。这个方法属于根类Object的一部分,将返回表示该对象类型的Class引用。

    	Dog dog = new Dog();
    	Class c2 = dog.getClass();
    
    1. 类字面常量:
    	//字面常量的方式获取Class对象
    	Class c3 = Dog.class;
    

    用类字面常量的方式来生成Class对象的引用,在编译时会受到检查(因此不需要置于try语句块中来捕获异常),相对前面两种方式显得更简单、更安全。

    采用字面常量的方式不仅可以应用于普通的类,也可以应用在接口、数组以及基本数据类型,这点在反射技术应用传递参数时很有帮助,关于反射技术稍后会分析。另外,因为基本数据类型有着对应的基本包装类型,其包装类型有一个标准字段TYPE,而这个TYPE就是一个引用,指向基本数据类型的Class对象,其等价转换如下:

    Class对象 TYPE字段
    boolean.class Boolean.TYPE
    char.class Character.TYPE
    byte.class Byte.TYPE
    short.class Short.TYPE
    int.class Integer.TYPE
    long.class Long.TYPE
    float.class Float.TYPE
    double.class Double.TYPE
    void.class Void.TYPE

    一般建议使用.class的形式,这样可以保持与普通类一致。

    上面我们分析了类加载的三个步骤,初始化被延迟到了对静态方法(构造器隐式地是静态的)或者非常熟静态域进行首次引用时才执行,而使用“.class”来创建Class对象时,触发的是加载阶段,并不会触发最后阶段类的初始化,下面引用《Java编程思想》中的例子来说明这点:

    import java.util.*;
    
    class Initable {
      //静态成员常量,编译期就确定值
      static final int staticFinal = 47;
      //静态成员常量,运行期才确定值
      static final int staticFinal2 =
        ClassInitialization.rand.nextInt(1000);
      //静态初始化块
      static {
        System.out.println("Initializing Initable");
      }
    }
    
    class Initable2 {
      //静态成员变量
      static int staticNonFinal = 147;
       //静态初始化块
      static {
        System.out.println("Initializing Initable2");
      }
    }
    
    class Initable3 {
      //静态成员变量
      static int staticNonFinal = 74;
      //静态初始化块
      static {
        System.out.println("Initializing Initable3");
      }
    }
    
    public class ClassInitialization {
      public static Random rand = new Random(47);
      public static void main(String[] args) throws Exception {
        //字面常量方法获取Class对象
        Class initable = Initable.class;
        System.out.println("After creating Initable ref");
        //不触发类初始化
        System.out.println(Initable.staticFinal);
        //会触发类初始化
        System.out.println(Initable.staticFinal2);
        //会触发类初始化
        System.out.println(Initable2.staticNonFinal);
        //forName()方法获取Class对象
        Class initable3 = Class.forName("Initable3");
        System.out.println("After creating Initable3 ref");
        System.out.println(Initable3.staticNonFinal);
      }
    }
    

    Output:

    After creating Initable ref
    47
    Initializing Initable
    258
    Initializing Initable2
    147
    Initializing Initable3
    After creating Initable3 ref
    74
    

    根据运行结果可以看出:

    1. 初始化有效地实现了尽可能的“惰性”,通过.Class语法来获取Initable类的Class对象时没有触发初始化,通过Class.forName()方式来获取Initable3类的Class对象时就进行了初始化。
    2. 调用Initable.staticFinal变量时,只输出了“47”,并没有打印“Initializing Initable”,说明也没有触发初始化,这是因为staticFinal值是“编译期静态常量”,在编译时其值“47”存储到了NotInitialization常量池中,对常量Initable.staticFinal的引用实际都被转化为NotInitialization类对自身常量池的引用了。如果将一个域只设置为static或final,如Initable2.staticNonFinal,还是会触发初始化。

    (类型转换和反射将后续更新)

    展开全文
  • java一个对象占用多少字节?

    千次阅读 2019-06-26 12:32:41
    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存? 1、JAVA 对象布局 在 HotSpot虚拟机中,对象在内存中的...

    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存?

    想弄清楚上面的问题,先补充一下基础知识。

    1、JAVA 对象布局

    在 HotSpot虚拟机中,对象在内存中的存储的布局可以分为三块区域:对象头(Header),实例数据(Instance Data)和对齐填充(Padding)

    1.1对象头(Header)
    Java中对象头由 Markword + 类指针kclass(该指针指向该类型在方法区的元类型) 组成。
    普通对象头在32位系统上占用8bytes,64位系统上占用16bytes。64位机器上,数组对象的对象头占用24个字节,启用压缩之后占用16个字节。

    用于存储对象自身的运行时数据,如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。在64位的虚拟机(未开启压缩指针)为64bit。
    Markword:
    在这里插入图片描述
    类指针kclass:
    kclass存储的是该对象所属的类在方法区的地址,所以是一个指针,默认Jvm对指针进行了压缩,用4个字节存储,如果不压缩就是8个字节。 关于Compressed Oops的知识,大家可以自行查阅相关资料来加深理解。

    如果对象是一个Java数组,那在对象头中还必须有一块用于记录数组长度的数据,这块占用4个字节。因为虚拟机可以通过普通Java对象的元数据信息确定Java对象的大小,但是从数组的元数据中无法确定数组的大小。
    (并不是所有的虚拟机实现都必须在对象数据上保留类型指针,换句话说,查找对象的元数据并不一定要经过对象本身,可参考对象的访问定位)

    1.2实例数据(Instance Data)
    实例数据部分就是成员变量的值,其中包含父类的成员变量和本类的成员变量。也就是说,除去静态变量和常量值放在方法区,非静态变量的值是随着对象存储在堆中的。
    因为修改静态变量会反映到方法区中class的数据结构中,故而推测对象保存的是静态变量和常量的引用。

    1.3对齐填充(Padding)
    用于确保对象的总长度为8字节的整数倍。
    HotSpot要求对象的总长度必须是8字节的整数倍。由于对象头一定是8字节的整数倍,但实例数据部分的长度是任意的。因此需要对齐补充字段确保整个对象的总长度为8的整数倍。

    2、Java数据类型有哪些

    • 基础数据类型(primitive type)
    • 引用类型 (reference type)

    2.1基础数据类型内存占用如下
    在这里插入图片描述2.2引用类型 内存占用如下:
    引用类型跟基础数据类型不一样,除了对象本身之外,还存在一个指向它的引用(指针),指针占用的内存在64位虚拟机上8个字节,如果开启指针压缩是4个字节,默认是开启了的。

    2.3字段重排序
    为了更高效的使用内存,实例数据字段将会重排序。排序的优先级为: long = double > int = float > char = short > byte > boolean > object reference
    如下所示的类

    class FieldTest{
            byte a;
            int c;
            boolean d;
            long e;
            Object f;
        }
    

    将会重排序为(开启CompressedOops选项):

       OFFSET  SIZE               TYPE DESCRIPTION            
             16     8               long FieldTest.e            
             24     4                int FieldTest.c            
             28     1               byte FieldTest.a            
             29     1            boolean FieldTest.d            
             30     2              (alignment/padding gap)
             32     8   java.lang.Object FieldTest.f
    

    3、验证

    讲完了上面的概念,我们可以去验证一下。
    3.1有一个Fruit类继承了Object类,我们分别新建一个object和fruit,那他们分别占用多大的内存呢?

    class Fruit extends Object {
         private int size;
    }
    
    Object object = new Object();
    Fruit f = new Fruit();
    

    先来看object对象,通过上面的知识,它的Markword是8个字节,kclass是4个字节, 加起来是12个字节,加上4个字节的对齐填充,所以它占用的空间是16个字节。
    再来看fruit对象,同样的,它的Markword是8个字节,kclass是4个字节,但是它还有个size成员变量,int类型占4个字节,加起来刚好是16个字节,所以不需要对齐填充。

    那该如何验证我们的结论呢?毕竟我们还是相信眼见为实!很幸运Jdk提供了一个工具jol-core可以让我们来分析对象头占用内存信息。具体使用参考
    jol的使用也很简单:
    打印头信息

    	public static void main(String[] args) {
    		System.out.print(ClassLayout.parseClass(Fruit.class).toPrintable());
    		System.out.print(ClassLayout.parseClass(Object.class).toPrintable());
    	}
    

    输出结果

    com.zzx.algorithm.tst.Fruit object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0    12        (object header)                           N/A
         12     4    int Fruit.size                                N/A
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    java.lang.Object object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0    12        (object header)                           N/A
         12     4        (loss due to the next object alignment)
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
    

    可以看到输出结果都是16 bytes,跟我们前面的分析结果一致。

    3.2 除了类类型和接口类型的对象,Java中还有数组类型的对象,数组类型的对象除了上面表述的字段外,还有4个字节存储数组的长度(所以数组的最大长度是Integer.MAX)。所以一个数组对象占用的内存是 8 + 4 + 4 = 16个字节,当然这里不包括数组内成员的内存。
    我们也运行验证一下。

    	public static void main(String[] args) {
    		String[] strArray = new String[0];
    		System.out.println(ClassLayout.parseClass(strArray.getClass()).toPrintable());
    	}
    

    输出结果:

    [Ljava.lang.String; object internals:
     OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
          0    16                    (object header)                           N/A
         16     0   java.lang.String String;.<elements>                        N/A
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    

    输出结果object header的长度也是16,跟我们分析的一致。
    3.3 接下来看对象的实例数据部分:
    为了方便说明,我们新建一个Apple类继承上面的Fruit类

    public class Apple extends Fruit {
    	private int size;
    	private String name;
    	private Apple brother;
    	private long create_time;
    	
    }
    

    // 打印Apple的对象分布信息

    System.out.println(ClassLayout.parseClass(Apple.class).toPrintable());
    

    // 输出结果

    com.zzx.algorithm.tst.Apple object internals:
     OFFSET  SIZE                          TYPE DESCRIPTION                               VALUE
          0    12                               (object header)                           N/A
         12     4                           int Fruit.size                                N/A
         16     8                          long Apple.create_time                         N/A
         24     4                           int Apple.size                                N/A
         28     4              java.lang.String Apple.name                                N/A
         32     4   com.zzx.algorithm.tst.Apple Apple.brother                             N/A
         36     4                               (loss due to the next object alignment)
    Instance size: 40 bytes
    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
    

    可以看到Apple的对象头12个字节,然后分别是从Fruit类继承来的size属性(虽然Fruit的size是private的,还是会被继承,与Apple自身的size共存),还有自己定义的4个属性,基础数据类型直接分配,对象类型都是存的指针占4个字节(默认都是开启了指针压缩),最终是40个字节,所以我们new一个Apple对象,直接就会占用堆栈中40个字节的内存,清楚对象的内存分配,让我们在写代码时心中有数,应当时刻有内存优化的意识!
    这里又引出了一个小知识点,上面其实已经标注出来了。

    父类的私有成员变量是否会被子类继承?
    答案当然是肯定的,我们上面分析的Apple类,父类Fruit有一个private类型的size成员变量,Apple自身也有一个size成员变量,它们能够共存。注意划重点了,类的成员变量的私有访问控制符private,只是编译器层面的限制,在实际内存中不论是私有的,还是公开的,都按规则存放在一起,对虚拟机来说并没有什么分别!

    4、方法内部new的对象是在堆上还是栈上?

    我们常规的认识是对象的分配是在堆上,栈上会有个引用指向该对象(即存储它的地址),到底是不是呢,我们来做个试验!
    我们在循环内创建一亿个Apple对象,并记录循环的执行时间,前面已经算过1个Apple对象占用40个字节,总共需要4GB的空间。

    public static void main(String[] args) {
         long startTime = System.currentTimeMillis();
         for (int i = 0; i < 100000000; i++) {
             newApple();
         }
         System.out.println("take time:" + (System.currentTimeMillis() - startTime) + "ms");
    }
    
    public static void newApple() {
         new Apple();
    }
    

    我们给JVM添加上-XX:+PrintGC运行配置,让编译器执行过程中输出GC的log日志
    // 运行结果,没有输出任何gc的日志

    take time:6ms
    

    1亿个对象,6ms就分配完成,而且没有任何GC,显然如果对象在堆上分配的话是不可能的,其实上面的实例代码,Apple对象全部都是在栈上分配的,这里要提出一个概念指针逃逸,newApple方法中新建的对象Apple并没有在外部被使用,所以它被优化为在栈上分配,我们知道方法执行完成后该栈帧就会被清空,所以也就不会有GC。
    我们可以设置虚拟机的运行参数来测试一下。
    // 虚拟机关闭指针逃逸分析

    -XX:-DoEscapeAnalysis
    

    // 虚拟机关闭标量替换

    -XX:-EliminateAllocations
    

    在VM options里面添加上面二个参数,再运行一次

    [GC (Allocation Failure)  236984K->440K(459776K), 0.0003751 secs]
    [GC (Allocation Failure)  284600K->440K(516608K), 0.0004272 secs]
    [GC (Allocation Failure)  341432K->440K(585216K), 0.0004835 secs]
    [GC (Allocation Failure)  410040K->440K(667136K), 0.0004655 secs]
    [GC (Allocation Failure)  491960K->440K(645632K), 0.0003837 secs]
    [GC (Allocation Failure)  470456K->440K(625152K), 0.0003598 secs]
    
    take time:5347ms
    

    可以看到有很多GC的日志,而且运行的时间也比之前长了很多,因为这时候Apple对象的分配在堆上,而堆是所有线程共享的,所以分配的时候肯定有同步机制,而且触发了大量的gc,所以效率低很多。
    总结一下: 虚拟机指针逃逸分析是默认开启的,对象不会逃逸的时候优先在栈上分配,否则在堆上分配。
    到这里,关于“一个对象占多少内存?”这个问题,已经能回答的相当全面了。

    5.看在Android ART虚拟机上面的分配情况

    我们前面使用了jol工具来输出对象头的信息,但是这个jol工具只能用在hotspot虚拟机上,那我们如何在Android上面获取对象头大小呢?
    可以使用sun.misc.Unsafe的objectFieldOffset方法,返回成员属性在内存中的地址相对于对象内存地址的偏移量
    根据前面的知识,普通对象的结构 就是 对象头+实例数据+对齐字节,那如果我们能获取到第一个实例数据的偏移地址,其实就是获得了对象头的字节大小
    5.1 如何拿到并使用Unsafe
    因为Unsafe是不可见的类,而且它在初始化的时候有检查当前类的加载器,如果不是系统加载器会报错。但是好消息是,AtomicInteger中定义了一个Unsafe对象,而且是静态的,我们可以直接通过反射来得到。

      public static Object getUnsafeObject() {
            Class clazz = AtomicInteger.class;
            try {
                Field uFiled = clazz.getDeclaredField("U");
                uFiled.setAccessible(true);
                return uFiled.get(null);
            } catch (NoSuchFieldException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            return null;
        }
    

    拿到了Unsafe,我们就可以通过调用它的objectFieldOffset静态方法来获取成员变量的内存偏移地址。

      public static long getVariableOffset(Object target, String variableName) {
            Object unsafeObject = getUnsafeObject();
            if (unsafeObject != null) {
                try {
                    Method method = unsafeObject.getClass().getDeclaredMethod("objectFieldOffset", Field.class);
                    method.setAccessible(true);
                    Field targetFiled = target.getClass().getDeclaredField(variableName);
                    return (long) method.invoke(unsafeObject, targetFiled);
                } catch (NoSuchMethodException e) {
                    e.printStackTrace();
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    e.printStackTrace();
                } catch (NoSuchFieldException e) {
                    e.printStackTrace();
                }
            }
            return -1;
        }
         public static void printObjectOffsets(Object target) {
            Class targetClass = target.getClass();
            Field[] fields = targetClass.getDeclaredFields();
            for (Field field : fields) {
                String name = field.getName();
                Log.e(">>>>>", name + " offset: " + getVariableOffset(target, name));
            }
        }
    

    输出结果:

    2019-06-25 15:57:59.176 6056-6056/com.zzx.readhub E/>>>>>: size offset: 8
    2019-06-25 15:57:59.176 6056-6056/com.zzx.readhub E/>>>>>: brother offset: 12
    2019-06-25 15:57:59.176 6056-6056/com.zzx.readhub E/>>>>>: create_time offset: 24
    2019-06-25 15:57:59.177 6056-6056/com.zzx.readhub E/>>>>>: name offset: 16
    2019-06-25 15:57:59.177 6056-6056/com.zzx.readhub E/>>>>>: size offset: 20
    

    通过输出结果,看出在 Android7.1 ART 虚拟机上,对象头的大小是8个字节,这跟hotspot虚拟机不同(hotspot是12个字节默认开启指针压缩),根据输出的结果目前只发现这一点差别,各种数据类型占用的字节数都是一样的,比如int占4个字节,指针4个字节,long8个字节等,都一样。

    总结

    全文我们总结了以下几个知识点

    Java虚拟机通过字节码指令来操作内存,所以可以说它并不关心数据类型,它只是按指令行事,不同类型的数据有不同的字节码指令。
    Java中基本数据类型和引用类型的内存分配知识,重点分析了引用类型的对象头,并介绍了JOL工具的使用
    延伸到Android平台,介绍了一种获取Android中对象的对象头信息的方法,并对比了ART和Hotspot虚拟机对象头长度的差别。

    展开全文
  • 1、JAVA 对象布局1.1对象头(Header):1.2实例数据(Instance Data)1.3对齐填充(Padding)2、Java数据类型有哪些2.1基础数据类型内存占用如下2.2引用类型 内存占用如下:2.3字段重排序3、验证3.1有一个Fruit类...

    一个Java对象占用多少字节?

    最近在读《深入理解Java虚拟机》,对Java对象的内存布局有了进一步的认识,于是脑子里自然而然就有一个很普通的问题,就是一个Java对象到底占用多大内存?

    想弄清楚上面的问题,先补充一下基础知识。

    1、JAVA 对象布局

    在 HotSpot虚拟机中,对象在内存中的存储的布局可以分为三块区域:对象头(Header),实例数据(Instance Data)和对齐填充(Padding)

    某些情况下,JVM根本就没有把Object放入堆中。例如:原则上讲,一个小的thread-local对象存在于栈中,而不是在堆中。
    被Object占用内存的大小依赖于Object的当前状态。例如:Object的同步锁是否生效,或者,Object是否正在被回收。
    我们先来看看在堆中单个的Object长什么样子
    在这里插入图片描述
    在堆中,每个对象由四个域构成(A、B、C 和 D),下面我们逐个解释一下:
    A:对象头,占用很少的字节,表述Object当前状态的信息
    B:基本类型域占用的空间(原生域指 int、boolean、short等)
    C:引用类型域占用的空间(引用类型域指 其他对象的引用,每个引用占用4个字节)
    D:填充物占用的空间(后面说明什么是填充物)

    1.1对象头(Header):

    Java中对象头由 Markword(8byte) + 类指针kclass(该指针指向该类型在方法区的元类型,默认开启压缩4byte,不开启为8byte) 组成,所以默认为12byte。

    用于存储对象自身的运行时数据,如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。在64位的虚拟机(未开启压缩指针)为64bit。
    Markword:
    在这里插入图片描述
    类指针kclass:
    kclass存储的是该对象所属的类在方法区的地址,所以是一个指针,默认Jvm对指针进行了压缩,用4个字节存储,如果不压缩就是8个字节。 关于Compressed Oops的知识,大家可以自行查阅相关资料来加深理解。

    如果对象是一个Java数组,那在对象头中还必须有一块用于记录数组长度的数据,这块占用4个字节(即数组默认为8+4+4=16byte)。因为虚拟机可以通过普通Java对象的元数据信息确定Java对象的大小,但是从数组的元数据中无法确定数组的大小。
    (并不是所有的虚拟机实现都必须在对象数据上保留类型指针,换句话说,查找对象的元数据并不一定要经过对象本身,可参考对象的访问定位)

    1.2实例数据(Instance Data)

    实例数据部分就是成员变量的值,其中包含父类的成员变量和本类的成员变量。也就是说,除去静态变量和常量值放在方法区,非静态变量的值是随着对象存储在堆中的。
    因为修改静态变量会反映到方法区中class的数据结构中,故而推测对象保存的是静态变量和常量的引用。

    1.3对齐填充(Padding)

    用于确保对象的总长度为8字节的整数倍。
    HotSpot要求对象的总长度必须是8字节的整数倍。由于对象头一定是8字节的整数倍,但实例数据部分的长度是任意的。因此需要对齐补充字段确保整个对象的总长度为8的整数倍。

    2、Java数据类型有哪些

    • 基础数据类型(primitive type)
    • 引用类型 (reference type)

    2.1基础数据类型内存占用如下

    在这里插入图片描述

    2.2引用类型 内存占用如下:

    引用类型跟基础数据类型不一样,除了对象本身之外,还存在一个指向它的引用(指针),指针占用的内存在64位虚拟机上8个字节,如果开启指针压缩是4个字节,默认是开启了的。

    2.3字段重排序

    为了更高效的使用内存,实例数据字段将会重排序。排序的优先级为: long = double > int = float > char = short > byte > boolean > object reference
    如下所示的类

    class FieldTest{
            byte a;
            int c;
            boolean d;
            long e;
            Object f;
        }
    

    将会重排序为(开启CompressedOops选项):

       OFFSET  SIZE               TYPE DESCRIPTION            
             16     8               long FieldTest.e            
             24     4                int FieldTest.c            
             28     1               byte FieldTest.a            
             29     1            boolean FieldTest.d            
             30     2              (alignment/padding gap)
             32     8   java.lang.Object FieldTest.f
    

    3、验证

    讲完了上面的概念,我们可以去验证一下。
    3.1有一个Fruit类继承了Object类,我们分别新建一个object和fruit,那他们分别占用多大的内存呢?

    class Fruit extends Object {
         private int size;
    }
    
    Object object = new Object();
    Fruit f = new Fruit();
    

    先来看object对象,通过上面的知识,它的Markword是8个字节,kclass是4个字节, 加起来是12个字节,加上4个字节的对齐填充,所以它占用的空间是16个字节。

    再来看fruit对象,同样的,它的Markword是8个字节,kclass是4个字节,但是它还有个size成员变量,int类型占4个字节,加起来刚好是16个字节,所以不需要对齐填充。

    那该如何验证我们的结论呢?毕竟我们还是相信眼见为实!很幸运Jdk提供了一个工具jol-core可以让我们来分析对象头占用内存信息。具体使用参考
    jol的使用也很简单:
    打印头信息

    public static void main(String[] args) {
    	System.out.print(ClassLayout.parseClass(Fruit.class).toPrintable());
    	System.out.print(ClassLayout.parseClass(Object.class).toPrintable());
    }
    

    输出结果

    com.zzx.algorithm.tst.Fruit object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0    12        (object header)                           N/A
         12     4    int Fruit.size                                N/A
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    java.lang.Object object internals:
     OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
          0    12        (object header)                           N/A
         12     4        (loss due to the next object alignment)
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
    

    可以看到输出结果都是16 bytes,跟我们前面的分析结果一致。

    3.2 除了类类型和接口类型的对象,Java中还有数组类型的对象,数组类型的对象除了上面表述的字段外,还有4个字节存储数组的长度(所以数组的最大长度是Integer.MAX)。所以一个数组对象占用的内存是 8 + 4 + 4 = 16个字节,当然这里不包括数组内成员的内存。

    我们也运行验证一下:

    public static void main(String[] args) {
    	String[] strArray = new String[0];
    	System.out.println(ClassLayout.parseClass(strArray.getClass()).toPrintable());
    }
    

    输出结果:

    [Ljava.lang.String; object internals:
     OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
          0    16                    (object header)                           N/A
         16     0   java.lang.String String;.<elements>                        N/A
    Instance size: 16 bytes
    Space losses: 0 bytes internal + 0 bytes external = 0 bytes total
    

    输出结果object header的长度也是16,跟我们分析的一致。
    3.3 接下来看对象的实例数据部分:
    为了方便说明,我们新建一个Apple类继承上面的Fruit类

    public class Apple extends Fruit {
    	private int size;
    	private String name;
    	private Apple brother;
    	private long create_time;
    	
    }
    

    // 打印Apple的对象分布信息
    System.out.println(ClassLayout.parseClass(Apple.class).toPrintable());

    // 输出结果

    com.zzx.algorithm.tst.Apple object internals:
     OFFSET  SIZE                          TYPE DESCRIPTION                               VALUE
          0    12                               (object header)                           N/A
         12     4                           int Fruit.size                                N/A
         16     8                          long Apple.create_time                         N/A
         24     4                           int Apple.size                                N/A
         28     4              java.lang.String Apple.name                                N/A
         32     4   com.zzx.algorithm.tst.Apple Apple.brother                             N/A
         36     4                               (loss due to the next object alignment)
    Instance size: 40 bytes
    Space losses: 0 bytes internal + 4 bytes external = 4 bytes total
    

    可以看到Apple的对象头12个字节,然后分别是从Fruit类继承来的size属性(虽然Fruit的size是private的,还是会被继承,与Apple自身的size共存),还有自己定义的4个属性,基础数据类型直接分配,对象类型都是存的指针占4个字节(默认都是开启了指针压缩),最终是40个字节,所以我们new一个Apple对象,直接就会占用堆栈中40个字节的内存,清楚对象的内存分配,让我们在写代码时心中有数,应当时刻有内存优化的意识!
    特别注意: String作为一个类的成员变量,是一个引用,大小为4byte , 但是如果单独拿出来计算String s=“string”;大小为24byte

    这里又引出了一个小知识点,上面其实已经标注出来了。

    父类的私有成员变量是否会被子类继承?
    答案当然是肯定的,我们上面分析的Apple类,父类Fruit有一个private类型的size成员变量,Apple自身也有一个size成员变量,它们能够共存。注意划重点了,类的成员变量的私有访问控制符private,只是编译器层面的限制,在实际内存中不论是私有的,还是公开的,都按规则存放在一起,对虚拟机来说并没有什么分别!

    4、方法内部new的对象是在堆上还是栈上?

    我们常规的认识是对象的分配是在堆上,栈上会有个引用指向该对象(即存储它的地址),到底是不是呢,我们来做个试验!
    我们在循环内创建一亿个Apple对象,并记录循环的执行时间,前面已经算过1个Apple对象占用40个字节,总共需要4GB的空间。

    public static void main(String[] args) {
         long startTime = System.currentTimeMillis();
         for (int i = 0; i < 100000000; i++) {
             newApple();
         }
         System.out.println("take time:" + (System.currentTimeMillis() - startTime) + "ms");
    }
    
    public static void newApple() {
         new Apple();
    }
    

    我们给JVM添加上-XX:+PrintGC运行配置,让编译器执行过程中输出GC的log日志
    // 运行结果,没有输出任何gc的日志
    take time:6ms

    1亿个对象,6ms就分配完成,而且没有任何GC,显然如果对象在堆上分配的话是不可能的,其实上面的实例代码,Apple对象全部都是在栈上分配的,这里要提出一个概念指针逃逸,newApple方法中新建的对象Apple并没有在外部被使用,所以它被优化为在栈上分配,我们知道方法执行完成后该栈帧就会被清空,所以也就不会有GC。
    我们可以设置虚拟机的运行参数来测试一下。
    // 虚拟机关闭指针逃逸分析
    -XX:-DoEscapeAnalysis

    // 虚拟机关闭标量替换
    -XX:-EliminateAllocations

    在VM options里面添加上面二个参数,再运行一次

    [GC (Allocation Failure)  236984K->440K(459776K), 0.0003751 secs]
    [GC (Allocation Failure)  284600K->440K(516608K), 0.0004272 secs]
    [GC (Allocation Failure)  341432K->440K(585216K), 0.0004835 secs]
    [GC (Allocation Failure)  410040K->440K(667136K), 0.0004655 secs]
    [GC (Allocation Failure)  491960K->440K(645632K), 0.0003837 secs]
    [GC (Allocation Failure)  470456K->440K(625152K), 0.0003598 secs]
    
    take time:5347ms
    

    可以看到有很多GC的日志,而且运行的时间也比之前长了很多,因为这时候Apple对象的分配在堆上,而堆是所有线程共享的,所以分配的时候肯定有同步机制,而且触发了大量的gc,所以效率低很多。
    总结一下: 虚拟机指针逃逸分析是默认开启的,对象不会逃逸的时候优先在栈上分配,否则在堆上分配。
    到这里,关于“一个对象占多少内存?”这个问题,已经能回答的相当全面了。

    参考文章:
    https://blog.csdn.net/zzx410527/article/details/93646925

    一个HashMap对象占多少字节?

    对象=对象头+成员变量+对齐填充

    对象头结构:java对象在Heap里面的结构是这样的:对象头跟对象体,对象体跟C里面的结构体是一样的,对象头由两个域组成:用于存放hashcode、同步、GC的_mask域,和指向方法区该对象Class对象的指针——_klass域,对于64位系统,头部长度理论上讲应该是8+8=16字节。但是从java6u23以后开始,64位的机器会自动开启指针压缩的功能,此时引用指针的长度为4字节。所以,对象头长度应该为8+4=12。

    成员变量:分两类,包括一些基本类型,如int,long.byte,short,boolean等,以及引用类型,如String,Date引用。如果是引用类型,也应该把引用类型指向的对象纳入当前对象。

    对齐填充:JVM规定,对象的大小必须是8字节的整数倍,如果不足,则会补齐。

    此外,对于数组,还会有一个标示数组长度的字段。其实数组也是一种类,会在后文中介绍。

    以此为理论基础,我们来计算一下常用的对象占用空间大小。

    Integer

    类结构图:可以看到,只有一个私有的int型数据

    img

    所以Integer长度为:头(8+4)+ int(4) = 16字节

    Long

    类结构图

    img

    类似于Integer,只有一个long型的私有成员。

    所以总长度为:头(8+4)+long(8)+padding(4)=24字节

    Object

    类结构图

    img

    没有成员变量,所以占用空间头(8+4)+padding(4)=16字节

    String:“string”

    类结构图

    img

    这个结构稍微有点复杂,涉及到了数组成员。其实数组也是一种类型,只不过这种类型是JVM在运行时生成的类型,并不在class文件中定义,我们将其当做一种特殊的类就可以了。既然涉及到了成员变量是对象,那么,我们就要把String分成两部分来计算:

    String类型:头部(8+4)+int(4)+int(4)+指向char[]对象的引用类型(4)=24字节

    char[]类型:数组类型比普通对象多一个标示数组长度的字段,占4个字节。对于字符串“String”来说,头部(8+4)+数组长度(4)+“String”(2*6)+padding(4)=32字节

    因此,它的总占用空间为56字节

    ArrayList

    类结构图

    img

    img

    其实,还有一个 modCount成员,继承自AbstractList类,那么对于一个 list = new ArrayList(); list.add(“String”);的list来说,它拥有两个int,一个大小为10的数组(当 list.add() 第一个元素的时候,它会初始化elementData为一个长度10的数组)

    ArrayList: 头部(8+4)+int(4)+int(4)+数组引用(4)=24字节

    elementData[] : 头部(8+4)+长度(4)+string引用(4*10)=56字节

    "String"字符串:这个我们之前计算过了,为56字节

    所以,总空间大小为24+56+56=136字节

    HashMap

    类结构图

    img

    HashMap内部结构比较复杂,除了一些基本的类型,还有比较复杂一点的集合类型。如table,是一个Entry数组,用来存放键值对,所有put进map中key-value都会被封装成一个entry放入到table中去。而还有一些辅助对象,如entry,继承自AbstractMap的keySet,values,这些都是在遍历map元素时用到的集合,他们的主要功能是通过在自己内部维护一个迭代器向外输出table中的数据,并不实际储存key-value数据。

    以 Map<String,String> map = new HashMap<String,String>(); 这时候我们计算一下他的占用空间情况:

    img

    总空间为:48+16=64字节

    hashmap:头部(8)+int(4*4)+float(4)+table数组引用(4)+entrySet引用(4)+keySet引用(4)+values引用(4)+padding(4)=48字节

    table:头部(8+4)+长度(4)=16字节

    然后我们put进去一条数据:map.put( “100002”, “张明”);

    当HashMap初始化的时候,他会开辟一个长度为16的table数组,每当put一个新的key-value的时候,他会根据当前threshold来判断是否需要扩容,如果需要扩容,则会以倍数增长的方式扩容table数组。如16、32、64.具体原理请参考 http://blog.csdn.net/zq602316498/article/details/39351363

    接下来让我们计算一下这个map多占用的空间

    img

    hashmap:头部(8)+int(4*4)+float(4)+table数组引用(4)+entrySet引用(4)+keySet引用(4)+values引用(4)+padding(4)=48字节

    table: 80+32+16+16+56+48+0= 216字节

    table:头部(8+4)+长度(4)+entry(4*16)=80字节

    entry:头部(8+4)+k(4)+value(4)+next(4)+int(4)+padding(4)=32字节

    img

    key(String):56字节

    value(String) :48字节

    next :因为就只有一个元素,所以next值为null,0字节

    entrySet:为空指针,0字节

    keySet:空指针,0字节

    values:空指针,0字节

    综上分析,这个map占用48+216+0+0+0=264字节

    然后我们继续调用 map.keySet() 方法,此时,keySet会被赋予一个类型为 HashMap$KeySet 的对象,这个对象的结构如下:

    img

    可以看到,它并不复杂,只是用来遍历map key集合的一个工具类,

    keySet : 头部(8+4)+padding(4)=16字节

    所以,总大小为264+16=280字节

    然后我们继续调动 map.values(),和上面类似

    img

    values : 头部(8+4)+padding(4)=16字节

    所以,总大小为 280+16=296字节

    然后我们继续调用 map.entrySet(),

    img

    entrySet:头部(8+4)+padding(4)=16字节

    所以总大小为 296+16=312字节

    参考文章:
    https://cloud.tencent.com/developer/article/1441801

    展开全文
  • 我写了两个类一个叫做Per另一个叫做Stu Stu类继承了Per类,然后我实例化了两个类的对象,接着我将子类的stu对象赋给父类的per对象 随后我使用hashCode()方法打印出了per对象刚刚生成的时候以及被赋值给stu对象之后...
  • java打印对象和toString方法

    万次阅读 2014-11-17 23:01:50
     toString()方法是一个非常特殊的方法,是一个“自我描述”方法,该方法通常用于实现当程序员直接打印对象时,系统将会输出该对象的“自我描述”信息,用以告诉外界该对象具有的状态信息。  Object类提供的...
  • Java打印对象和toString方法

    千次阅读 2017-04-12 09:56:04
    1、打印对象和toString方法:toString方法是系统将会输出该对象的“自我描述”信息,用以告诉外界对象具有的状态信息。 2、Object 类提供的toString方法总是返回该对象实现类的类名 + @ +hashCode值。   二 打印...
  • java面向对象

    万次阅读 多人点赞 2018-08-21 16:51:59
    包括面向对象概念、类与对象的关系、封装、构造函数、this关键字、static关键字、单例设计模式、继承、多态、内部类、异常、包等java基础知识。 1、面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是...
  • Java 泛型,你了解类型擦除吗?

    万次阅读 多人点赞 2017-08-05 22:32:18
    泛型是 Java 中一个很小巧的概念,但同时也是一个很容易让人迷惑的知识点,它让人迷惑的地方在于它的许多表现有点违反直觉。文章开始的地方,先给大家奉上一道经典的测试题。List&lt;String&gt; l1 = new ...
  • 今天在修改程序的时候,发现一个小细节的问题,对此进行了总结下: 一个简单的例子如下: ArrayList list=new ArrayList(); Long id=10006L; list.add(10006); System.out.println(list.con
  • Java类型信息(Class对象)与反射机制

    千次阅读 2018-09-17 13:31:55
    RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thinking in Java》一书,其作用是在运行时识别一个对象类型和类的信息。 这里分两种...
  • 深入理解Class对象 ...认识Class对象之前,先来了解一个概念,RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thin...
  • Java数组属于引用类型对象,以此为例说明地址引用和内容复制的区别 1.地址引用 为一个数组变量赋值另一个数组变量后,2个数组变量指向同一个内存地址,引用同一个数组对象,此时内存中并没有建立新的数组对象。 2....
  • 深入理解Java类型信息(Class对象)

    千次阅读 多人点赞 2019-05-19 19:36:01
    RTTI(Run-Time Type Identification)运行时类型识别,对于这个词一直是 C++ 中的概念,至于Java中出现RRTI的说法则是源于《Thinking in Java》一书,其作用是在运行时识别一个对象类型和类的信息。这里分两种: ...
  • new一个对象java虚拟机做了什么?

    千次阅读 2017-07-21 12:43:34
    当刚写完一个java程序,main方法new一个对象,内存做了如下操作: 初期: 程序先进入编译时期,jre将程序代码编译成字节码信息; 中期 首先通过类装载器载入类文件的字节码信息,经过解析后将其装入内存方法...
  • Java中如何获得一个对象所对应的类及Class类的简单理解 前言 在之前的学习中,所用的编程语言主要是Python,最近开始学习Java,熟悉Python的同学应该会知道在Python中有一个函数type(),通过这个函数可以非常...
  • 总所周知,Java将程序员从内存...在此之前,我们先来复习一个Java对象回收有关的知识,那便是finalize方法,这是一个在Object类中定义的方法,如果我们重写了finalize方法,那么在对象被回收之前将会调用finaliz...
  • Java集合不能存放基本数据类型,只存放对象的引用

    万次阅读 多人点赞 2017-05-06 13:52:15
    1. 集合存储对象Java集合中实际存放的只是对象的引用,每个集合元素都是一个引用变量,实际内容都放在堆内存或者方法区里面,但是基本数据类型是在栈内存上分配空间的,栈上的数据随时就会被收回的。2.
  • 最近在学习java对象内存布局方面的一些知识,主要是想知道一个java对象到底占用多少内存空间,以及java对象在内存中到底是什么样子的。c/c++中的sizeof运算符能够方便地告诉我们一个变量占用的内存空间,但是在java...
  • 浅谈一下JAVA对象对象引用以及对象赋值

    万次阅读 多人点赞 2013-09-19 00:50:29
    浅谈一下JAVA对象对象引用以及对象赋值   今天有班级同学问起JAVA对象的引用是什么。正好趁着这次机会,自己总结一下JAVA对象对象引用以及对象赋值。自己总结了所看到的网上相关方面的不少帖子,整理汇总形成...
  • 浅谈java对象引用及对象赋值

    千次阅读 多人点赞 2017-01-05 15:11:46
    一、Java对象及其引用  初学Java,总是会自觉或不自觉地把Java和C++相比较。在学习Java类与对象章节的时候,发现教科书和许多参考书把对象对象的引用混为一谈。... 为便于说明,我们先定义一个简单的类:  c
  • Java对象模型

    千次阅读 2020-02-06 14:44:49
    Java对象模型
  • JVM通过加装、连接和初始化一个Java类型,使该类型可以被正在运行的Java程序所使用。类型的生命周期如下图所示: 装载和连接必须在初始化之前就要完成。 类初始化阶段,主要是为类变量赋予正确的初始值。这里的...
  • Java 与 C++ 创建对象

    千次阅读 2014-07-18 14:14:55
    创建对象:C++和Java的异同
  • java对象赋值操作

    千次阅读 2015-08-16 15:14:20
    所以当将一个对象赋值给另一个对象实际上是将对象的引用从一个地方赋值到另一个地方。当我么将一个对象赋值给另一个对象后,我们修改其中的一个对象,另一个对象也随之改变。class Tank{ int m; } public class ...
  • Java中Class对象详解

    万次阅读 多人点赞 2018-06-01 14:50:40
    https://blog.csdn.net/mcryeasy/article/details/52344729待...每类的运行时的类型信息就是用Class对象表示的。它包含了与类有关的信息。其实我们的实例对象就通过Class对象来创建的。Java使用Class对象执行其RT...
  • Java面向对象基础

    万次阅读 多人点赞 2015-11-05 16:33:28
    java语言是面向对象的 计算机语言的发展由面向机器向面向对象发展的,是越来越符合人的思维习惯的。   符合人类思维习惯程度 低 → 高  面向机器 汇编语言 面向过程 C语言 面向对象 Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 188,222
精华内容 75,288
关键字:

java打印一个对象的实际类型

java 订阅