Java源码解析(2) —— Class(1)

心已赠人 2022-09-26 02:53 217阅读 0赞

# Class —— 反射基石 #

Java基本类之一，反射机制的基础。其意义为：类的抽象，即对“类”做描述：比如类有修饰、字段、方法等属性，有获得该类的所有方法、所有公有方法等方法。同时，Class也是Java类型中最重要的一种，表示原始类型（引用类型）及基本类型。

## 声明 ##

1.Class的源码太长，这里分4部分解析，一些方法的实现源代码较长，这里就没有贴出来了，我会着重将叙述其作用，至于其实现逻辑，以本人现有水平估计也很难一一讲解清晰，大家姑且看之，若其中有错误地方或未讲解明白的可留言探讨。  
2.阅读该文前，若对反射和泛型知识有一定基础最好。

## 源码 ##

public final
        class Class<T> implements java.io.Serializable,
                                java.lang.reflect.GenericDeclaration,
                                  java.lang.reflect.Type,
                                  java.lang.reflect.AnnotatedElement {
        private static final int ANNOTATION= 0x00002000;//注释类型
        private static final int ENUM      = 0x00004000;//枚举类型
        private static final int SYNTHETIC = 0x00001000;//合成类型，注0
        //枚举是一种类（class），注释是一种接口（interface）
        private transient String name;//全限定名（包+类名）
        private native String getName0();//本地方法获取name属性
        //注册本地方法
        private static native void registerNatives();
        static {
            registerNatives();
        }
        private Class() {}//唯一私有构造方法，说明Class不可由用户构造实例
        public String toString() {
            //这里重写toString，只区别了接口和Class
            return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
                + getName();
        }
        //通过类全限定名获得该类（或接口）的Class对象（加载该类）
        @CallerSensitive   //注1
        public static Class<?> forName(String className)
                    throws ClassNotFoundException {
            Class<?> caller = Reflection.getCallerClass();
            return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
        }
        @CallerSensitive
        public static Class<?> forName(String name, boolean initialize,
                                       ClassLoader loader)
            throws ClassNotFoundException
        {
            //initialize : 是否立即初始化该类，注2
            //loader : 使用指定的类加载器加载
        }
        private static native Class<?> forName0(String name, boolean initialize,
                                                ClassLoader loader,
                                                Class<?> caller)
            throws ClassNotFoundException;
        //反射获得该类实例对象
     @CallerSensitive
        public T newInstance()
            throws InstantiationException, IllegalAccessException
        {
        //JDK明言：本方法在当前Java内存模型下不一定是正确的
            //反射获取该类实例对象，实例化对象不是通过new指令，而是直接
            //通过本地方法获取类的公有构造方法（无参），然后通过Constructor的
            //newInstance();方法实例化对象
            //这个过程还要检查是否有权限反射实例化该对象
        }
        //缓存上面方法已获取的公有构造方法，供下次使用
        private volatile transient Constructor<T> cachedConstructor;
        //缓存调用本方法的最初对象的类Class对象，供安全检查使用，见注1
        private volatile transient Class<?>       newInstanceCallerCache;
        //判断obj对象是否是该Class的实例
        public native boolean isInstance(Object obj);
        //判断cls是否是调用者同一类型或其子类类型
        public native boolean isAssignableFrom(Class<?> cls);
        //判断该Class是否是接口类型
        public native boolean isInterface();
        //判断该Class是否是数组类型
        public native boolean isArray();
        //判断该Class是否是基本类型，注3（八大基本类型+一特殊基本类型）
        public native boolean isPrimitive();
        //判断该Class是否是注释类型
        public boolean isAnnotation() {
            return (getModifiers() & ANNOTATION) != 0;
        }
        //判断该Class是否是合成类型
        public boolean isSynthetic() {
            return (getModifiers() & SYNTHETIC) != 0;
        }
        public String getName() {
            String name = this.name;
            if (name == null)
                this.name = name = getName0();//通过本地方法获取全路径类名
            return name;
        }
        //获取加载该类的类加载器
        @CallerSensitive
        public ClassLoader getClassLoader() {
            ClassLoader cl = getClassLoader0();
            if (cl == null)
                return null;
            SecurityManager sm = System.getSecurityManager();//注5
            if (sm != null) {
                ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
            }
            return cl;
        }
        native ClassLoader getClassLoader0();
        //返回该类中变量字段的类型变量数组，按声明顺序排序，注4
        public TypeVariable<Class<T>>[] getTypeParameters() {
            if (getGenericSignature() != null)
                return (TypeVariable<Class<T>>[])getGenericInfo().getTypeParameters();
            else
                return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
        }
        //获得该类的直接父类的Class对象，如果该类是接口，则返回null
        public native Class<? super T> getSuperclass();
        //返回带参数化类型的直接父类的类型
        public Type getGenericSuperclass() {}
        //获取该类的包路径
        public Package getPackage() {
            return Package.getPackage(this);
        }
        //获取该类直接实现的所有接口
        public native Class<?>[] getInterfaces();
        //获取所有接口，同上面的不同之处在于，若超接口是参数化类型（泛型）则返回的是其实际类型
        public Type[] getGenericInterfaces() {
            if (getGenericSignature() != null)
                return getGenericInfo().getSuperInterfaces();
            else
                return getInterfaces();
        }
        /**返回数组类型，若该类不是数组，返回null * 如：A[] a = new A[]; * a.getClass().getComponentType()返回的是A类型（全路径名） */
        public native Class<?> getComponentType();
        //返回这个类的修饰符的对应的int值，二者可通过Modifier.toString()转换
        public native int getModifiers();
        //获取该类的所有签名（标记）列表
        public native Object[] getSigners();
        //设置该类的签名，注意方法修饰是默认，所以只有同包下类可用
        native void setSigners(Object[] signers);
        /** * 以上两个方法不是很懂具体用来干什么的，估计是和安全检查什么有关，因为 * setSigners()是默认修饰，只能同包下访问（这就是说，用户是用不了的） */
    }

注0：合成类型，参考：[synthetic Java合成类型][synthetic Java]  
注1：@CallerSensitive注解，参考：[JVM注解@CallSensitive（HEL\_WOR）][JVM_CallSensitive_HEL_WOR]  
注2：类的初始化  
　　forName()方法默认是初始化类，不需要加载的的时候同时初始化类，需用forName的重载函数。类的加载、初始化可参考：[Java类的加载][Java]  
注3：Java基本数据类型  
　　除了8大基本类型，还有void，详见：[Java变量数据类型][Java 1]  
注4：Java类型，详见：[Type Java类型][Type Java]。  
注5：关于Java安全策略之安全管理器，现可以参考：[java安全沙箱（四）（xionghuiCoder）][java_xionghuiCoder]

## 概述 ##

Class类，表示Java的基础类型（类+基本类型），是对Java类的抽象，描述的是类的信息，包括类的修饰符（public/private/protect/default/static/final等）、类的类型（一般类、枚举、注释、接口、数组等）、类的构造器、类的字段、类的方法等信息。所以在看待Class相关问题的时候应该从所有类的共性这个角度去看。注意，这里的类不是平常我们说的狭义上的类（class），而是广义上，包括了像接口、注释、数组等类型的类，下面若不特殊声明，类代表着广义上的类。  
　　每一个类在JVM内存中，有一个唯一的对应的Class对象，这个对象有着该类的描述信息，所以运行时可以通过该Class类对象进行相应的操作，这就是Java的反射了。（Java基本类型也对应一个Class对象）

//获得Class对象的方法
    //1.通过 类型.class 获得，适用于所有类型
    Class str = String.class;
    Class i = int.class;
    Class d = Double[].class;
    //2.通过 Object的getClass() 方法获得，适用于所有非基本类型
    A a = new A(); Class ac = a.getClass();
    //3.通过 Class.forName(String name) 方法获得
    Class ac1 = Class.forName("com.fcc.test.A");//注意要用全限定名

## 源码详解 ##

1.forName  
　　静态方法，通过类的全限定名加载类，返回该类的Class对象，forName有两个重载，forName(String)和forName(String, boolean, ClassLoader)，其中，第一个参数是类的全限定名，第二个参数是指加载该类的后是否初始化该类，默认是加载后并初始化该类，最后一个参数是指使用哪个类加载器加载该类，默认是使用当前类的类加载器加载该类。  
2.newInstance  
　　创建该Class对象对应的对象实例，只有当类具有公有的无参构造方法才能成功，否则抛异常，关于newInstance详见：newInstance和new（编辑中）。  
3.getClassLoader  
　　获得加载该类的类加载器，在本JVM（Oracle HotSopt），当本类的类加载器是引导类加载器（bootStrap）则返回的是null。（类的加载见上面注2。）  
4.getTypeParameters  
　　返回该类中声明（定义）的类变量数组，例如：

//关于TypeVariable详见注3
    public class Main<K, V> {
        public static void main(String[] args) throws Exception
        {
            Class cl = Main.class;
            TypeVariable[] types = cl.getTypeParameters();
            for(TypeVariable type : types){
                System.out.println(type.getName());
            }
        }
    }
    K
    V

5.getSuperclass  
　　获得该Class的直接父类对应的Class对象，如果该Class是基本类型（包括void，注意是小写的关键字void，不是大写的类Void）、接口、注释，则返回null。

Class c0 = Main.class;//类,返回直接父类,泛型当做普通类处理
    Class c1 = EnumA.class;//枚举类型,默认继承Enum类
    Class c2 = int.class;//基本类型返回null
    Class c3 = int[].class;//数组统一返回 class Object
    Class c4 = InterfaceB.class;//接口也是返回null
    Class c5 = Deprecated.class;//注释类型也返回null,c5.isInterface() 为true
    System.out.println("类 : " + c0.getSuperclass());
    System.out.println("枚举 : " + c1.getSuperclass());
    System.out.println("基本类型 : " + c2.getSuperclass());
    System.out.println("数组 : " + c3.getSuperclass());
    System.out.println("接口 : " + c4.getSuperclass());
    System.out.println("注释 : " + c5.getSuperclass());
    //输出结果
    类 : class java.lang.Object
    枚举 : class java.lang.Enum
    基本类型 : null
    数组 : class java.lang.Object
    接口 : null
    注释 : null

6.getGenericSuperclass  
　　获得直接父类的类型，可以理解为在5的基础上，如果其是泛型，再获得其类型原型（但需要继承时显式表示）。

public class Main<K, V> { 
        public static void main(String[] args) throws Exception
        {
            Class c0 = ClassA.class;
            Class c1 = EnumA.class;//枚举类型,默认继承Enum类
            Class c2 = int.class;//基本类型返回null
            Class c3 = ClassA[].class;//数组统一返回 class Object
            Class c4 = InterfaceB.class;//接口也是返回null
            Class c5 = Deprecated.class;//注释类型也返回null
            System.out.println("类 : " + c0.getGenericSuperclass());
            System.out.println("枚举 : " + c1.getGenericSuperclass());
            System.out.println("基本类型 : " + c2.getGenericSuperclass());
            System.out.println("数组 : " + c3.getGenericSuperclass());
            System.out.println("接口 : " + c4.getGenericSuperclass());
            System.out.println("注释 : " + c5.getGenericSuperclass());
            System.out.println(c2.isInterface());
        }
    }
    class ClassA<K,V> extends Main<K,V>{ }//注1
    //输出结果
    类 : com.fcc.test.Main<K, V>
    枚举 : java.lang.Enum<com.fcc.test.EnumA>
    基本类型 : null
    数组 : class java.lang.Object
    接口 : null
    注释 : null
    注1：如果是以下形式
    class ClassA extends Main{ }
    则输出为：类 : com.fcc.test.Main

7.getInterfaces  
8.getGenericInterfaces  
　　getInterfaces/getGenericInterfaces这一对同getSuperclass/getGenericSuperclass类似，getInterfaces/getGenericInterfaces前者是获得该类直接实现的所有接口（不包括接口的父接口，也不包括父类实现的接口），后者是，如果接口是泛型，还原泛型的原型（但需要实现时显式表示，这一点同getGenericSuperclass类似）。不过不管是哪一对，要注意，返回值类型的不同。

Class c0 = ClassB.class; Class[] ifaces = c0.getInterfaces(); for(Class c : ifaces){ System.out.println(c); } Type[] ifaces1 = c0.getGenericInterfaces(); for(Type c : ifaces1){ System.out.println(c); } class ClassB<E> extends ClassA implements InterfaceB<E>{ } //输出结果 interface com.fcc.test.InterfaceB com.fcc.test.InterfaceB<E>

[synthetic Java]: http://blog.csdn.net/a327369238/article/details/52608805
[JVM_CallSensitive_HEL_WOR]: http://blog.csdn.net/hel_wor/article/details/50199797
[Java]: http://blog.csdn.net/a327369238/article/details/52068692
[Java 1]: http://blog.csdn.net/a327369238/article/details/52238102
[Type Java]: http://blog.csdn.net/a327369238/article/details/52621043
[java_xionghuiCoder]: https://my.oschina.net/xionghui/blog/501225