JDK1.8源码阅读（6）–Error/Exception/Class
一.Error类
类图：
Error类继承于Throwable类
static final long serialVersionUID = 4980196508277280342L; 序列号
public Error()
构造方法，这里用的是父类Throwable的构造方法
public Error() {
super();
}
public Error(String message) 父类的构造方法
public Error(String message) {
//
super(message);
}
public Error(String message, Throwable cause)
public Error(Throwable cause)
protected Error(String message, Throwable cause,
boolean enableSuppression,
boolean writableStackTrace)
可以看到Error类主要的就是4个构造方法，其他的都是使用Throwable类的
二.Exception类
类图：
static final long serialVersionUID = -3387516993124229948L; 序列号
除了四个构造方法外，其他的也一样。
三.Class类
类图：
实现了Type接口，GenericDeclaration接口，AnnotatedElement接口，Serializable接口，首先先看看这几个接口定义了什么：
1️⃣Type接口：
代表Java中的“类型”
主要包括5种实现：Class，TypeVariable，ParameterizedType，WildcardType，GenericArrayType
//返回当前类型的详细介绍
default String getTypeName() {
return toString();
}
2️⃣AnnotatedElement接口,
//判断当前元素上是否存在注解
default boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) {
return getAnnotation(annotationClass) != null;
}
//返回该元素上指定类型的注解（对于类来说，包括继承来的注解）
<T extends Annotation> T getAnnotation(Class<T> annotationClass)
返回该元素上所有类型的注解（对于类来说，包括继承来的注解）
Annotation[] getAnnotations()
//返回该元素上指定类型的注解（对于类来说，包括继承来的注解）
default <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
/*
* Definition of associated: directly or indirectly present OR
* neither directly nor indirectly present AND the element is
* a Class, the annotation type is inheritable, and the
* annotation type is associated with the superclass of the
* element.
*/
T[] result = getDeclaredAnnotationsByType(annotationClass);
if (result.length == 0 && // Neither directly nor indirectly present
this instanceof Class && // the element is a class
AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable
Class<?> superClass = ((Class<?>) this).getSuperclass();
if (superClass != null) {
// Determine if the annotation is associated with the
// superclass
result = superClass.getAnnotationsByType(annotationClass);
}
}
return result;
}
//返回该元素上指定类型的注解（对于类来说，不包括继承来的注解）
default <T extends Annotation> T getDeclaredAnnotation(Class<T> annotationClass) {
Objects.requireNonNull(annotationClass);
// Loop over all directly-present annotations looking for a matching one
for (Annotation annotation : getDeclaredAnnotations()) {
if (annotationClass.equals(annotation.annotationType())) {
// More robust to do a dynamic cast at runtime instead
// of compile-time only.
return annotationClass.cast(annotation);
}
}
return null;
}
//返回该元素上指定类型的注解（对于类来说，不包括继承来的注解）
default <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
Objects.requireNonNull(annotationClass);
return AnnotationSupport.
getDirectlyAndIndirectlyPresent(Arrays.stream(getDeclaredAnnotations()).
collect(Collectors.toMap(Annotation::annotationType,
Function.identity(),
((first,second) -> first),
LinkedHashMap::new)),
annotationClass);
}
//返回该元素上所有类型的注解（对于类来说，不包括继承来的注解）
Annotation[] getDeclaredAnnotations();
3️⃣GenericDeclaration接口
泛型元素，指有能力引入泛型声明的元素，比如类、方法、构造器
返回generic type中的type variable，如：Map<K, V>中的K和V
public TypeVariable<?>[] getTypeParameters();
接下来进入Class类的源码分析：
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 Class(ClassLoader loader) {
classLoader = loader;
}
//重写toString方法，是否是接口，如果是接口输出“interface”；如果不是，判断是否是基本类型，如果是就输出“”，不是输出“class”，最后加个名称
public String toString() {
return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
+ getName();
}
//打印类完整声明
public String toGenericString() {
if (isPrimitive()) {
return toString();
} else {
StringBuilder sb = new StringBuilder();
// 加入修饰符
int modifiers = getModifiers() & Modifier.classModifiers();
if (modifiers != 0) {
sb.append(Modifier.toString(modifiers));
sb.append(' ');
}
//加入是否是注解
if (isAnnotation()) {
sb.append('@');
}
//是否是接口
if (isInterface()) { // Note: all annotation types are interfaces
sb.append("interface");
} else {
//是否是枚举类
if (isEnum())
sb.append("enum");
else
sb.append("class");
}
sb.append(' ');
sb.append(getName());
//泛型
TypeVariable<?>[] typeparms = getTypeParameters();
if (typeparms.length > 0) {
boolean first = true;
sb.append('<');
for(TypeVariable<?> typeparm: typeparms) {
if (!first)
sb.append(',');
sb.append(typeparm.getTypeName());
first = false;
}
sb.append('>');
}
return sb.toString();
}
}
//根据类的全名加载类对象，而且加载类之后对类的静态元素进行初始化
@CallerSensitive
public static Class<?> forName(String className)
throws ClassNotFoundException {
Class<?> caller = Reflection.getCallerClass();
return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
}
//根据类的全名和指定的类加载器加载类对象，initialize参数指示是否在加载类之后对类中的静态元素进行初始化
@CallerSensitive
public static Class<?> forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException
{
Class<?> caller = null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
// Reflective call to get caller class is only needed if a security manager
// is present. Avoid the overhead of making this call otherwise.
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);
// 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 (InstantiationException)
new InstantiationException(getName()).initCause(e);
}
}
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;
}
}
private volatile transient Constructor<T> cachedConstructor; 构造器缓存
private volatile transient Class<?> newInstanceCallerCache; 调用者类的缓存
//本地方法，判断是否是一个对象
public native boolean isInstance(Object obj);
//判断cls是否是当前类的父类
public native boolean isAssignableFrom(Class<?> cls)
//判断是否是个接口
public native boolean isInterface();
public native boolean isArray(); 判断是否是个数组
//判读是否是个基础类型
public native boolean isPrimitive();
//判断是否有注释
public boolean isAnnotation() {
return (getModifiers() & ANNOTATION) != 0;
}
//判断修饰符是否是synthetic
public boolean isSynthetic() {
return (getModifiers() & SYNTHETIC) != 0;
}
//返回类的姓名
public String getName() {
String name = this.name;
if (name == null)
this.name = name = getName0();
return name;
}
private transient String name; 姓名的缓存
private native String getName0(); 获取当前类的名称
//得到当前类所使用的类加载器
@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; 类加载器是一个常量，一个类智能指定唯一的类加载器
//返回generic type中的type variable，如：Map<K, V>中的K和V
public TypeVariable<Class<T>>[] getTypeParameters() {
ClassRepository info = getGenericInfo();
if (info != null)
return (TypeVariable<Class<T>>[])info.getTypeParameters();
else
return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
}
public native Class<? super T> getSuperclass();
本地方法，得到父类
//获取当前类的父类（可识别泛型类型和非泛型类型）
public Type getGenericSuperclass() {
ClassRepository info = getGenericInfo();
if (info == null) {
return getSuperclass();
}
if (isInterface()) {
return null;
}
return info.getSuperclass();
}
//获取当前类所在包的package信息
public Package getPackage() {
return Package.getPackage(this);
}
//获取当前类的父接口，不包括父类/父接口实现的接口（只识别非泛型类型）
public Class<?>[] getInterfaces() {
ReflectionData<T> rd = reflectionData();
if (rd == null) {
// no cloning required
return getInterfaces0();
} else {
Class<?>[] interfaces = rd.interfaces;
if (interfaces == null) {
interfaces = getInterfaces0();
rd.interfaces = interfaces;
}
// defensively copy before handing over to user code
return interfaces.clone();
}
}
private native Class<?>[] getInterfaces0();
//获取当前类的父接口，不包括父类/父接口实现的接口（识别泛型类型）
public Type[] getGenericInterfaces() {
ClassRepository info = getGenericInfo();
return (info == null) ? getInterfaces() : info.getSuperInterfaces();
}
//获取数组的组件类型，如int[]返回int，int[][]返回int[]。如果不是数组，则返回空
public native Class<?> getComponentType();
public native int getModifiers(); //得到修饰符
//获取签名信息
public native Object[] getSigners();
native void setSigners(Object[] signers);
//内部静态类，描述了内部类以及方法名称和方法描述。
private final static class EnclosingMethodInfo {
private Class<?> enclosingClass;
private String name;
private String descriptor;
private EnclosingMethodInfo(Object[] enclosingInfo) {
if (enclosingInfo.length != 3)
throw new InternalError("Malformed enclosing method information");
try {
// The array is expected to have three elements:
// the immediately enclosing class
enclosingClass = (Class<?>) enclosingInfo[0];
assert(enclosingClass != null);
// the immediately enclosing method or constructor's
// name (can be null).
name = (String) enclosingInfo[1];
// the immediately enclosing method or constructor's
// descriptor (null iff name is).
descriptor = (String) enclosingInfo[2];
assert((name != null && descriptor != null) || name == descriptor);
} catch (ClassCastException cce) {
throw new InternalError("Invalid type in enclosing method information", cce);
}
}
boolean isPartial() {
return enclosingClass == null || name == null || descriptor == null;
}
boolean isConstructor() { return !isPartial() && "<init>".equals(name); }
boolean isMethod() { return !isPartial() && !isConstructor() && !"<clinit>".equals(name); }
Class<?> getEnclosingClass() { return enclosingClass; }
String getName() { return name; }
String getDescriptor() { return descriptor; }
}
//得到内部方法明细
private EnclosingMethodInfo getEnclosingMethodInfo() {
Object[] enclosingInfo = getEnclosingMethod0();
if (enclosingInfo == null)
return null;
else {
return new EnclosingMethodInfo(enclosingInfo);
}
}
//得到这个类是在哪个方法中定义的
@CallerSensitive
public Method getEnclosingMethod() throws SecurityException {
EnclosingMethodInfo enclosingInfo = getEnclosingMethodInfo();
if (enclosingInfo == null)
return null;
else {
if (!enclosingInfo.isMethod())
return null;
MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(),
getFactory());
Class<?> returnType = toClass(typeInfo.getReturnType());
Type [] parameterTypes = typeInfo.getParameterTypes();
Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
// Convert Types to Classes; returned types *should*
// be class objects since the methodDescriptor's used
// don't have generics information
for(int i = 0; i < parameterClasses.length; i++)
parameterClasses[i] = toClass(parameterTypes[i]);
// Perform access check
Class<?> enclosingCandidate = enclosingInfo.getEnclosingClass();
enclosingCandidate.checkMemberAccess(Member.DECLARED,
Reflection.getCallerClass(), true);
/*
* Loop over all declared methods; match method name,
* number of and type of parameters, *and* return
* type. Matching return type is also necessary
* because of covariant returns, etc.
*/
for(Method m: enclosingCandidate.getDeclaredMethods()) {
if (m.getName().equals(enclosingInfo.getName()) ) {
Class<?>[] candidateParamClasses = m.getParameterTypes();
if (candidateParamClasses.length == parameterClasses.length) {
boolean matches = true;
for(int i = 0; i < candidateParamClasses.length; i++) {
if (!candidateParamClasses[i].equals(parameterClasses[i])) {
matches = false;
break;
}
}
if (matches) { // finally, check return type
if (m.getReturnType().equals(returnType) )
return m;
}
}
}
}
throw new InternalError("Enclosing method not found");
}
}
private static Class<?> toClass(Type o) {
if (o instanceof GenericArrayType)
return Array.newInstance(toClass(((GenericArrayType)o).getGenericComponentType()),
0)
.getClass();
return (Class<?>)o;
}
//如果该类是构造函数中生成的，那么返回这个构造函数
public Constructor<?> getEnclosingConstructor()
//获取[成员内部类]所处的外部类(仅对成员内部类有效)，如果并非内部类，则返回null
public Class<?> getDeclaringClass() throws SecurityException
//获取[内部类]所处的外部类（对成员内部类、方法内部类、匿名内部类均有效）
public Class<?> getEnclosingClass() throws SecurityException
// 简单名称，可以看做是不带包名和外部类名的规范名（匿名类没有）
char 基本类型
char[] 基本类型数组
Outer 引用类型
Outer[] 引用类型数组
Inner 内部类
匿名类
Outer$$Lambda$1/1989780873 Lambda表达式
public String getSimpleName()
// 类型名称
char 基本类型
char[] 基本类型数组
com.kang.Outer 引用类型
com.kang.Outer[] 引用类型数组
com.kang.Outer$Inner 内部类
com.kang.Outer$1 匿名类
com.kang.Outer$$Lambda$1/1989780873 Lambda表达式
public String getTypeName()
//判断是否是ascii码
private static boolean isAsciiDigit(char c)
//规范名称，尽量遵从书写习惯（匿名类为null）
char 基本类型
char[] 基本类型数组
com.kang.Outer 引用类型
com.kang.Outer[] 引用类型数组
com.kang.Outer.Inner 内部类
null 匿名类
com.kang.Outer$$Lambda$1/1989780873 Lambda表达式
public String getCanonicalName()
//是不是匿名类
public boolean isAnonymousClass()
//是不是方法内部类
public boolean isLocalClass()
//是不是成员内部类
public boolean isMemberClass()
//返回内部类的名称
private String getSimpleBinaryName()
//是不是方法内部类或者匿名内部类
private boolean isLocalOrAnonymousClass()
// 获取当前类包含的内部类/接口，仅包含public修饰的内部接口、内部抽象类、内部实例类，会继承父类内容，但不会继承父接口的内容
public Class<?>[] getClasses() {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
return java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Class<?>[]>() {
public Class<?>[] run() {
List<Class<?>> list = new ArrayList<>();
Class<?> currentClass = Class.this;
while (currentClass != null) {
Class<?>[] members = currentClass.getDeclaredClasses();
for (int i = 0; i < members.length; i++) {
if (Modifier.isPublic(members[i].getModifiers())) {
list.add(members[i]);
}
}
currentClass = currentClass.getSuperclass();
}
return list.toArray(new Class<?>[0]);
}
});
}
// 返回当前类中所有public字段，包括父类/父接口中的public字段
public Field[] getFields() throws SecurityException {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), true);
return copyFields(privateGetPublicFields(null));
}
public Method[] getMethods() 获取所有public修饰的方法
public Constructor<?>[] getConstructors() 获取所有的public修饰构造函数
public Field getField(String name) 获取指定名称的public修饰的字段
public Method getMethod(String name, Class<?>... parameterTypes) 得到指定名称指定参数的public修饰的方法
public Constructor<T> getConstructor(Class<?>... parameterTypes) 得到指定名称指定参数的public修饰的构造方法
public Class<?>[] getDeclaredClasses() // 获取当前类包含的内部类/接口，包含所有权限修饰符修饰的内部接口、内部抽象类、内部实例类，不会继承父类和父接口的内容
public Field[] getDeclaredFields() 获得所有的字段
public Method[] getDeclaredMethods() 获取所有的方法
public Constructor<?>[] getDeclaredConstructors() 获取所有的构造函数
public Field getDeclaredField(String name) 获取指定名称的字段
public Method getDeclaredMethod(String name, Class<?>... parameterTypes) 获取指定名称和参数的方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 获取指定名称和参数的构造函数
// /*
* 查找指定名称的资源，并返回其输入流。
* 如果当前类位于命名模块，则在模块路径(根目录)下查找；否则，在类路径(根目录)上查找。
*
* resName路径内部需以"/"分割。
* 如果resName以'/'开头，则会在模块路径/类路径的根目录下查找；
* 如果resName不以'/'开头，则会在(当前类所在目录+"/"+resName)下查找
*/
public InputStream getResourceAsStream(String name)
//查找指定名称的资源，并返回其URL。
public java.net.URL getResource(String name)
//检查类的可访问性
private void checkMemberAccess(int which, Class<?> caller, boolean checkProxyInterfaces) {
final SecurityManager s = System.getSecurityManager();
if (s != null) {
final ClassLoader ccl = ClassLoader.getClassLoader(caller);
final ClassLoader cl = getClassLoader0();
if (which != Member.PUBLIC) {
if (ccl != cl) {
s.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
}
}
this.checkPackageAccess(ccl, checkProxyInterfaces);
}
}
如果resName以'/'开头，则去掉开头的"/"后返回；否则，将当前类所在包名转换为路径，并将该路径添加到resName前面后返回
private String resolveName(String name)
619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
