java源码分析06-Class

妖狐艹你老母 2022-08-10 03:59 139阅读 0赞

苦闷的来源，即在于心地不单纯。

哼着女儿国里的歌曲，爱恋伊...，一手拿着垃圾袋，打开门，她出现在你眼前，

内心有着激动，担忧.

还是来学习java的Class类吧。

1.类结构

![Center][]

2.类解析

我第一次遇到她，是在JDBC的使用时，用来加载驱动，Class.forName()，还需要

捕获异常。

public static Class<?> forName(String className)
                    throws ClassNotFoundException {
            return forName0(className, true,
                            ClassLoader.getClassLoader(Reflection.getCallerClass()));
        }

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

上述代码，我们知道，第一，该方法抛出了Class不存在异常，所以调用处需要捕获或者在方法上

抛出；第二，类加载需要用到类加载器。

第二次，遇到她，是反射机制，创建对象的时候，她还是那么迷人，低调而有内涵。

@CallerSensitive
        public T newInstance()
            throws InstantiationException, IllegalAccessException
        {
            if (System.getSecurityManager() != null) {
                checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
            }
    
            // NOTE: the following code may not be strictly correct under
            // the current Java memory model.
    
            // Constructor lookup
            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);
                    // Disable accessibility checks on the constructor
                    // since we have to do the security check here anyway
                    // (the stack depth is wrong for the Constructor's
                    // security check to work)
                    java.security.AccessController.doPrivileged(
                        new java.security.PrivilegedAction<Void>() {
                            public Void run() {
                                    c.setAccessible(true);
                                    return null;
                                }
                            });
                    cachedConstructor = c;
                } catch (NoSuchMethodException e) {
                    throw new InstantiationException(getName());
                }
            }
            Constructor<T> tmpConstructor = cachedConstructor;
            // Security check (same as in java.lang.reflect.Constructor)
            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;
            }
        }

上述方法的作用就是利用外部传入的字符串来加载类，并创建对象。

当然，我们还可以利用反射机制来设值，这一点在Spring的IOC中有所体现。

有时候，某些属性是private的，所以首先需要设定我们可以访问它，然后再

通过getDeclaredFileds()来获取所有的属性。

[Center]: /images/20220731/4cb55cdabf224a268bc7a93ed1223a57.png