Class类详解

一、Class的定义

Class 类的实例表示 正在运行的 Java 应用程序中的类和接口。枚举是一种类，注解是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。 

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。 

public final class Class<T> implements java.io.Serializable,
                              GenericDeclaration, //泛型定义
                              Type, //Type 是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
                              AnnotatedElement //注解元素, 提供一些注解相关api
							  {

    /*构造函数私有化，只有Java虚拟机才能加载
     * Private constructor. Only the Java Virtual Machine creates Class objects.
     * This constructor is not used and prevents the default constructor being
     * generated.
     */
    private Class(ClassLoader loader) {
        // Initialize final field for classLoader.  The initialization value of non-null
        // prevents future JIT optimizations from assuming this final field is null.
        classLoader = loader;
    }
    private final ClassLoader classLoader;						  
}		

二、获取Class的三种方式

1、类.class

2、对象.getClass()

3、Class.forName("包名.类名")

package reflect;

/**
 * java.lang.Class
 * 
 * @author zhangquanit
 */
public class ClassTest {
	public static void main(String[] args) throws Exception {
		//类.class
		Class<?> clazz=ClassTest.class;
		
		//对象.getClass()
		clazz=new ClassTest().getClass();
		
		//Class.forName(包名.类名)
		clazz=Class.forName("reflect.ClassTest");
       
	}
}

三、API详解

package reflect;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;


/**
 * java.lang.Class
 * 
 * @author zhangquanit
 */
@MyAnnotation
public class ClassTest {

	public void method(String param) {

	}

	public void method2(String param) {

	}
	
	

	public static class Father implements MyInterface {
		// Father内部类
		public class FatherInnerClass {

		}
	}

	public static class Child<T> extends Father implements MyInterface,MyInterface2<T>{
		// Child内部类
		public class ChildInnerClass {

		}
	}
	
	public static void main(String[] args) throws Exception {

		/*
		 * boolean isInstance(Object obj) 
		 * 判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
		 */
		ArrayList<String> arrayList = new ArrayList<String>();
		// List是ArrayList的父类
		boolean isInstance = List.class.isInstance(arrayList); // true
		// ArrayList实例
		isInstance = ArrayList.class.isInstance(arrayList); // true
		// ArrayList实现了Collection
		isInstance = Collection.class.isInstance(arrayList); // true

		/*
		 * T cast(Object obj) 
		 * 将一个对象强制转换成此 Class 对象所表示的类或接口。 
		 * 也就是可向父类或实现的接口转型
		 */
		// arrayList转换为List类型，因为List是ArrayList的父类
		List list = List.class.cast(arrayList);
		// arrayList转换为Collection类型,因为ArrayList实现了Collection接口
		Collection collection = Collection.class.cast(arrayList);

		/*
		 * 获取类上的注解(Annotation)、成员变量(Field)、构造方法(Constructor)、方法(Method)
		 * 1、获取当前类所有的 getDeclaredXX 
		 * 2、获取当前类和父类中公有的 getXX
		 */
		Method[] methods = null;
		Method method = null;
		// 当前类和父类中的公有方法
		methods = ClassTest.class.getMethods();
		method = ClassTest.class.getMethod("method", String.class);
		// 当前类中的方法
		methods = ClassTest.class.getDeclaredMethods();
		method = ClassTest.class.getDeclaredMethod("method", String.class);

		/*
		 * Class<?>[] getClasses
		 * 当前类和父类中修饰符为public的内部类、内部接口、内部注解等。
		 */
		Class<?>[] classes = Child.class.getClasses();
		/*
		 * Class<?>[] getDeclaredClasses
		 * 当前类中定义的所有内部类、内部接口、内部注解等。
		 */
		classes = Child.class.getDeclaredClasses();
		
		/*
		 * ClassLoader getClassLoader()
		 * 返回该类的类加载器。
		 */
		ClassLoader classLoader = ClassTest.class.getClassLoader();
		
		/*
		 * Class<?> getComponentType()
		 * 返回表示数组中元素的类型。
		 */
		String[] array=new String[2];
		Class<?> componentType = array.getClass().getComponentType();//class java.lang.String
         
		/*
		 * getEnclosingClass:该类是在那个类中定义的， 比如直接定义的内部类或匿名内部类
		 * getEnclosingConstructor：该类是在哪个构造函数中定义的，比如构造方法中定义的匿名内部类
		 * getEnclosingMethod：该类是在哪个方法中定义的，比如方法中定义的匿名内部类
		 */
		Class<?> enclosingClass = Child.class.getEnclosingClass();//class reflect.ClassTest
		
		/*
		 * T[] getEnumConstants()
		 * 返回枚举类的元素
		 */
		MyEnum[] enumConstants = MyEnum.class.getEnumConstants();//[MAN, WOMAN]
		
		/*
		 * Class<?>[] getInterfaces
		 * 该类实现的所有接口,不包括父类实现的接口
		 */
		Class<?>[] interfaces = Child.class.getInterfaces();
		//[interface reflect.MyInterface, interface reflect.MyInterface2]
		
		/*
		 * Type[] getGenericInterfaces
		 * 该类实现的所有接口Type.不包括父类实现的接口
		 */
		Type[] genericInterfaces = Child.class.getGenericInterfaces();
		//[interface reflect.MyInterface, reflect.MyInterface2<T>]
		
		/*
		 * Class<? super T> getSuperclass
		 * 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
		 */
		Class<? super Child> superclass = Child.class.getSuperclass();
		
		/*
		 * Type getGenericSuperclass
		 * 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。
		 */
		Type genericSuperclass = Child.class.getGenericSuperclass();
		
		/*
		 * int getModifiers
		 * 返回此类或接口以整数编码的 Java 语言修饰符。
		 */
		int modifiers = ClassTest.class.getModifiers();
		String modify = Modifier.toString(modifiers);//public
		
		/*
		 * Package getPackage
		 * 获取此Class所在的包
		 */
		Package pkg = ClassTest.class.getPackage();
		String packageName=pkg.getName();// reflect
		
		/*
		 * InputStream getResourceAsStream(String name)
		 * 加载指定名称的资源,以'/'开头表示绝对路径，即绝对于src目录
		 */
		InputStream resourceAsStream = ClassTest.class.getResourceAsStream("config/resource.txt");
		// 表示加载 "/reflect/config/resource.txt" 
		
		/*
		 * TypeVariable<Class<T>>[] getTypeParameters
		 * 获取该class上定义的泛型
		 */
		TypeVariable<Class<Child>>[] typeParameters = Child.class.getTypeParameters();
		//  Child类上定义的泛型   T
		
		/*
		 * 类型判断
		 * boolean isAnnotation
		 * 是否为注解
		 * 
		 */
		boolean annotation = MyAnnotation.class.isAnnotation();
		
		/*
		 * boolean isAnonymousClass
		 * 当前类是否为匿名类
		 */
		List<String> innerList=new ArrayList<String>(){
			@Override
			public boolean add(String e) {
				//当前类为匿名类
				boolean anonymousClass = this.getClass().isAnonymousClass();
				return super.add(e);
			}
		};
		innerList.add("1");
		boolean isAnonymousClass=Child.class.isAnonymousClass();//false Child是内部类，不是匿名类
		/*
		 * boolean isArray
		 * 是否为数组
		 */
		boolean isArray = String[].class.isArray(); //true
		/*
		 * boolean isAssignableFrom(Class<?> cls)
		 * ClassA表示的类或接口是否为参数ClassB的父类或父接口
		 */
		boolean assignableFrom = Father.class.isAssignableFrom(Child.class); //true
		/*
		 * boolean isEnum
		 * 是否为枚举
		 */
		boolean isEnum = MyEnum.class.isEnum(); //true
		
		/*
		 * boolean isInterface
		 * 是否为接口
		 */
		boolean isInterface = MyInterface.class.isInterface();//true
		
		/*
		 * boolean isMemberClass
		 * 是否为成员类，即内部类
		 */
		boolean isMemberClass = Father.class.isMemberClass();//true
		
		/*
		 * boolean isPrimitive
		 * 是否为基本数据类型
		 */
		 boolean isPrimitive = int.class.isPrimitive(); //true
		 
		 /*
		  * T newInstance
		  *  创建此 Class 对象所表示的类的一个新实例。注意，该类中必须有无参的构造函数
		  */
		 ClassTest classTest = ClassTest.class.newInstance();
		
	}
}