JDK軟件包1.8java.lang之Class

Class類的實例表示正在運行的Java應用程序中的類和接口。每個數組屬於被映射爲Class對象的一個類，所有具有相同元素類型和緯數的數組共享該Class對象。Class對象是在加載類時由虛擬機通過類加載器defineClass方法自動構造的。所有定位維護的類和接口，都是Class的實例。Object類方法唯一引入返回的類型。基本數據類型和void關鍵字都是Class類的實例。Final修飾，是不變類，不能被繼承。實現了反射包java.lang.reflect中的三接口：AnnotatedElement、GenericDeclaration、Type。Type是java語言中所有類型的公共高級接口。包括原始類型、參數化類型、數組類型、類型變量、基本類型(1.5版本纔有的)；1.8版本對此接口增加一個默認方法。

package java.lang.reflect;

public interface Type {
    /**
     * 返回類型的字符串描述
     */
    default String getTypeName() {
        return toString();
    }
}

GenericDeclaration是聲明類型變量的所有實例的公共接口。返回一個聲明順序的類型變量的數組，如果未聲明類型變量，返回數組長度是0。

    /**
     * 返回Class類的一個對象，就是接口或者類。相當於查找加載類
     */
    @CallerSensitive
    public static Class<?> forName(String className)throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }


    /**
     * 返回一個指定加載器的Class類的一個對象實例(類和接口)
     * 是否必須初始化類
     */
    @CallerSensitive
    public static Class<?> forName(String name, boolean initialize,ClassLoaderloader)
throws ClassNotFoundException {
        Class<?> caller = null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            caller = Reflection.getCallerClass();
            if (sun.misc.VM.isSystemDomainLoader(loader)) {
                ClassLoader ccl = ClassLoader.getClassLoader(caller);
                if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
                    sm.checkPermission(
                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
        }
        return forName0(name, initialize, loader, caller);
    }


    private static native Class<?> forName0(String name, boolean initialize,
                                            ClassLoader loader,
                                            Class<?> caller)
        throws ClassNotFoundException;

    @CallerSensitive
    public T newInstance() throws InstantiationException, IllegalAccessException {
        if (System.getSecurityManager() != null) {
            checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
        }

        if (cachedConstructor == null) {
            if (this == Class.class) {
                throw new IllegalAccessException(
                    "Can not call newInstance() on the Class for java.lang.Class"
                );
            }
            try {
                Class<?>[] empty = {};
                final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
                java.security.AccessController.doPrivileged(
                    new java.security.PrivilegedAction<Void>() {
                        public Void run() {
                                c.setAccessible(true);
                                return null;
                            }
                        });
                cachedConstructor = c;
            } catch (NoSuchMethodException e) {
                throw (InstantiationException)
                    new InstantiationException(getName()).initCause(e);
            }
        }
        Constructor<T> tmpConstructor = cachedConstructor;
        int modifiers = tmpConstructor.getModifiers();
        if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            if (newInstanceCallerCache != caller) {
                Reflection.ensureMemberAccess(caller, this, null, modifiers);
                newInstanceCallerCache = caller;
            }
        }
        // Run constructor
        try {
            return tmpConstructor.newInstance((Object[])null);
        } catch (InvocationTargetException e) {
            Unsafe.getUnsafe().throwException(e.getTargetException());
            // Not reached
            return null;
        }
    }

創建此 Class 對象所表示的類的一個新實例。如同用一個帶有一個空參數列表的 new 表達式實例化該類。如果該類尚未初始化，則初始化這個類。

    public String getName() {
        String name = this.name;
        if (name == null)
            this.name = name = getName0();
        return name;
    }

    private transient String name;
    private native String getName0();

返回Class對象實例所表示的類或接口名(全路徑名)。

    @CallerSensitive
    public ClassLoader getClassLoader() {
        ClassLoader cl = getClassLoader0();
        if (cl == null)
            return null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            ClassLoader.checkClassLoaderPermission(cl, Reflection.getCallerClass());
        }
        return cl;
    }

    ClassLoader getClassLoader0() { return classLoader; }

    private final ClassLoader classLoader;

返回該類的加載器，引導加載器類返回的是null ;基本類型或者void都會返回Null。

    public Package getPackage() {
        return Package.getPackage(this);
    }

返回此類的包名。

    public Class<?>[] getInterfaces() {
        ReflectionData<T> rd = reflectionData();
        if (rd == null) {
            return getInterfaces0();
        } else {
            Class<?>[] interfaces = rd.interfaces;
            if (interfaces == null) {
                interfaces = getInterfaces0();
                rd.interfaces = interfaces;
            }
            return interfaces.clone();
        }
    }
private native Class<?>[] getInterfaces0();

返回此實例對象所表示類或接口所實現的接口。