首先看看Class 的声明：
public final
class Class implements java.io.Serializable,
java.lang.reflect.GenericDeclaration,
java.lang.reflect.Type,
java.lang.reflect.AnnotatedElement
Final 的，而且支持泛型，实现了某些接口。
/**
* Instances of the class {@code Class} represent classes and
* interfaces in a running Java application. An enum is a kind of
* class and an annotation is a kind of interface. Every array also
* belongs to a class that is reflected as a {@code Class} object
* that is shared by all arrays with the same element type and number
* of dimensions. The primitive Java types ({@code boolean},
* {@code byte}, {@code char}, {@code short},
* {@code int}, {@code long}, {@code float}, and
* {@code double}), and the keyword {@code void} are also
* represented as {@code Class} objects.
*/
通过注释可以看到，主要有这么几类。
接口， 枚举，注解，数组，java基本类型 都可以通过Class 间接得到。
/*
* Constructor. Only the Java Virtual Machine creates Class
* objects.
*/
private Class() {}
也就是说一般不能人为的实例化Class实例。
public String toString() {
return (isInterface() ? "interface " : (isPrimitive() ? "" : "class "))
+ getName();
}
toString 方法：
返回值：interface， class 或者是空串“”。java基本类型 返回值只有类型，不存在具体包名。
public static Class<?> forName(String className)
throws ClassNotFoundException {
return forName0(className, true, ClassLoader.getCallerClassLoader());
}
用于实例化某个JVM上的Class，ClassLoader.getCallerClassLoader() 返回调用该方法的ClassLoader。
在看看它的重载方法：
public static Class<?> forName(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException
{
if (loader == null) {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
ClassLoader ccl = ClassLoader.getCallerClassLoader();
if (ccl != null) {
sm.checkPermission(
SecurityConstants.GET_CLASSLOADER_PERMISSION);
}
}
}
return forName0(name, initialize, loader);
}
只是增加了security 检查，以及设置initialize 参数的能力。
这两个方法最终都调用了一个native 方法
private static native Class<?> forName0(String name, boolean initialize,
ClassLoader loader)
throws ClassNotFoundException;
在看看newInstate 方法
public T newInstance()
throws InstantiationException, IllegalAccessException
{// 检查该构造方法是不是public的， 如果是就直接调用newInstance0
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, ClassLoader.getCallerClassLoader());
}
return newInstance0();
}
private T newInstance0()
throws InstantiationException, IllegalAccessException
{
// NOTE: the following code may not be strictly correct under
// the current Java memory model.
// Constructor lookup 检查该类不是Class 类，因为Class类只能有JVM实例化。
if (cachedConstructor == null) {
if (this == Class.class) {
throw new IllegalAccessException(
"Can not call newInstance() on the Class for java.lang.Class"
);
}
try {
//设置构造方法的参数为空数组，这就是而为什么用newInstance实例化类需要有一个为空的构造方法的原因。
Class<?>[] empty = {};
//获取构造参数为空的，构造方法
final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
//下面都是做一些security 检查和access设置
// 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(3);
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;
}
}
/**
* Determines if the specified {@code Object} is assignment-compatible
* with the object represented by this {@code Class}. This method is
* the dynamic equivalent of the Java language {@code instanceof}
* operator. The method returns {@code true} if the specified
* {@code Object} argument is non-null and can be cast to the
* reference type represented by this {@code Class} object without
* raising a {@code ClassCastException.} It returns {@code false}
* otherwise.
....
*/
public native boolean isInstance(Object obj);
isInstance 方法，通过注释可以知道该方法主要用于判断：参数obj 是否与调用者Class（某个类对应的Class）兼容。 简单一点的就是说 参数obj 能否 Cast 为调用者对应的类。
自身类.class.isInstance(自身实例或子类实例) 返回true
String s = new String("test");
System.out.println(Object.class.isInstance(s)); //true
String 可以cast 为object。
/**
* Determines if the class or interface represented by this
* {@code Class} object is either the same as, or is a superclass or
* superinterface of, the class or interface represented by the specified
* {@code Class} parameter. It returns {@code true} if so;
* otherwise it returns {@code false}. If this {@code Class}
* object represents a primitive type, this method returns
* {@code true} if the specified {@code Class} parameter is
* exactly this {@code Class} object; otherwise it returns
* {@code false}.
*
...
*/
public native boolean isAssignableFrom(Class<?> cls);
isAssignableFrom 与isInstance 方法类似只是参数不同。