JavaSE之反射四大核心类

Class、Constructor、Method、Field

class : 反射核心类，描述其他类的类结构
每个类的class对象有且只有一个，由JVM在类加载时创建
class类对象的三种实例化模式：
1.任何类的实例化对象都可以通过Object类的getclass（）方法取得Class类对象
2.类名.class
3.调用Class提供的静态方法Class.forName(类名（含包名))

利用Class对象反射创建类的对象
取得包名称 : getPackage()
取得父类的Class对象： getSuperclass()
取得实现的父接口： public Class<?>  getInterfaces()

反射调用构造（加Declared为本类，不加为本类和父类）
1.取得指定参数类型的构造
public Constructor<T> getConstructor(Class<?>...)
2.取得类中的所有构造
public Constructor<?>[] getConstructors()

反射调用普通方法（加Declared为本类，不加为本类和父类）
1.取得全部普通方法
public Method[] getMethods()
2.取得指定普通方法
public Method getMethod(String name,Class<?>...)
3.调用
public invoke(Object obj,Object...args)

反射调用类中属性（加Declared为本类，不加为本类和父类）
1.取得类中全部属性
public Field[] getFields()
2.取得类中指定属性
public Field getField(String name)
3.设置属性内容
public void set(Object obj(实例化对象),Object value(属性值))
4.取得属性内容
public Object get(Object obj(实例化对象))

下面进行一些基本操作方法的实例；

注：注释中内容均为以上方法的具体使用，包由读者自行导入

interface IFruit {}
interface IMessage {}
class MyClass implements IFruit,IMessage {
	private String name;
	private Integer age;
	public MyClass() {}
	public MyClass(String name) {}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
}
public class Test {
	public static void main(String[] args) throws Exception {
        
        //class类对象的三种实例化模式：
		//方法1
//		Object object = new Object();
//		Class<? extends Object> cls = object.getClass();
		//方法2
//		Class<Object> cls = Object.class;
//		//方法3
//		Class<?> cls = Class.forName("java.util.Date");
//		Object object = cls.newInstance();
//		System.out.println(cls.getName());//实例化对象，等价于new
//		System.out.println(object);
		

        //利用Class对象反射创建类的对象：
		//取得包名称
//		Class<?> cls = MyClass.class;//取得Class类对象
//		System.out.println(cls.getPackage().getName());//取得包名称
//		System.out.println(cls.getSuperclass().getName());//取得父类包名称
//		//取得实现的父接口对象
//		Class<?>[] icClass = cls.getInterfaces();
//		for (Class<?> class1 : icClass) {
//			System.out.println(class1.getName());
		
		
        //反射调用构造（加Declared为本类，不加为本类和父类）
		//取得类中全部构造
//		Class<?> cls = MyClass.class;
//		Constructor<?>[] constructors = cls.getDeclaredConstructors();
//		for(Constructor<?> constructor : constructors) {
//			System.out.println(constructor);
//		}
		

        //反射调用普通方法（加Declared为本类，不加为本类和父类）
		//取得一个类中全部普通方法
//		Class<?> cls = MyClass.class;
//		Method[] methods = cls.getDeclaredMethods();
//		for (Method method : methods) {
//			System.out.println(method);
//		}
		

        //反射调用类中属性（加Declared为本类，不加为本类和父类）
		//取得一个类中的属性
		Class<?> cls = MyClass.class;
		Field[] fields = cls.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field);
		}
	}
}