java 反射

//java反射机制
允许运行中的 java程序对自身进行检测，
可以直接操作程序内部的属性
Class类与java反射
Class类常用方法
//强制转换Class对象，以表示指定的类对象所表示的类的一个子集
public <U> Class<? extends U> asSubclass(Class <U> clazz)

//将一个对象强制转换成此 Class对象所表示的类或接口
public T cast(Object obj)
.....
//使用Object类中的getClass()方法
package org.com.classdemo;
class SuperClass
{
	public void show()
	{
		System.out.println("这是SuperClass类的show()方法");
	}
}
class SubClass extends SuperClass
{
	public void show()
	{
		System.out.println("这是SubClass类的show()方法");
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		SuperClass sup = new SuperClass();
		SubClass sub = new SubClass();
		Class c1 = sup.getClass();
		Class c2 = sub.getClass();
		System.out.println("类名："+c1.getName());
		System.out.println("类名："+c2.getName());
	}
}
编译： javac -d . Hi.java
运行：java org.com.classdemo.Hi
/*
类名：org.com.classdemo.SuperClass
类名：org.com.classdemo.SubClass
*/
// ============
//使用 forName()方法加载对象
//其中forName()返回的是Class实例，不是所加载类的实例
package org.com.classdemo;
class LocaderClass
{
	static
	{
		System.out.println("这是LocaderClass类的静态代码块");
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Class c = null;
		try
		{
			// 加载LocaderClass对象
			c = Class.forName("org.com.classdemo.LocaderClass");
		}catch(ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		// 输出对象所在类的名称
		System.out.println("类名："+c.getName());
	}
}
/*
E:\javap>javac -d . Hi.java

E:\javap>java org.com.classdemo.Hi
这是LocaderClass类的静态代码块
类名：org.com.classdemo.LocaderClass
*/
// -------------
使用用类标记
package org.com.classdemo;
class LocaderClass
{
	static
	{
		System.out.println("这是locaderclass类的静态代码块");
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		// 声明Class对象 c
		Class c = LocaderClass.class;
		System.out.println("类名："+c.getName());
	}
}
/*
E:\javap>javac -d . Hi.java

E:\javap>java org.com.classdemo.Hi
类名：org.com.classdemo.LocaderClass
*/
// ===============
使用反射机制生成并操作对象
通过无参构造实例化对象
package org.com.classdemo;
class Student
{
	private String name;
	private int age;
	public Student(){}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return "姓名："+getName()+",年龄："+getAge();
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		// 定义 Class对象
		Class<?> c = null;
		// 定义 Student 对象
		Student stu = null;
		try
		{
			// 加载LocaderClass对象,必须要完整的，包.类名
			c = Class.forName("org.com.classdemo.Student");
		}catch(ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		try
		{
			//向下转型为 Student对象
			stu = (Student)c.newInstance();
		}catch(InstantiationException e)
		{
			e.printStackTrace();
		}catch(IllegalAccessException e)
		{
			e.printStackTrace();
		}
		stu.setName("小二");
		stu.setAge(20);
		System.out.println("对象信息："+stu);
	}
}
/*
E:\javap>javac -d . Hi.java

E:\javap>java org.com.classdemo.Hi
对象信息：姓名：小二,年龄：20
*/
// ============
调用有参构造方法
提供了使用java.lang.reflect.Constructor类根据类的
指定构造方法创建对象.使用Constructor类操作时，根据明确地
调用类中的构造方法，并将参数传递进去，即可实例化操作
具体如下：
获取类 Class对象，再通过 Class类中的 getConstructor()方法
取得Constructor类的实例
通过Constructor类的实例，调用 newInstance()方法并传
入指定构造方法所需要的参数创建对象

调用类中指定的构造方法
package org.com.classdemo;
import java.lang.reflect.Constructor;
class Student
{
	private String name;
	private int age;
	// 必须显示写无构构造方法
	public Student()
	{
		this.name = "小二";
		this.age = 21;
	}
	// 必须显示写无构构造方法
	public Student(String name)
	{
		this.name = name;
	}
	public Student(String name, int age)
	{
		this.name = name;
		this.age = age;
	}
	public Student(int age)
	{
		this.age = age;
	}
	public void setName(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public void setAge(int age)
	{
		this.age = age;
	}
	public int getAge()
	{
		return age;
	}
	public String toString()
	{
		return "姓名："+getName()+"，年龄："+getAge();
	}
}
public class Hi
{
	public static void main(String[] args)
	{
		Class<?> c = null;
		Student stu1 = null;
		Student stu2 = null;
		Student stu3 = null;
		Student stu4 = null;
		Constructor<?> con[] = null;
		try
		{
			// 加载LocaderClass对象
			c = Class.forName("org.com.classdemo.Student");
		}catch(ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		// 实例化Constructor
		con = c.getConstructors();
		for(int i=0; i<con.length;i++)
		{
			// 输出con数组，代表各个构造方法
			System.out.println(i+"--------"+con[i]);
		}
		try
		{
			stu1 = (Student) con[0].newInstance(20);
			stu2 = (Student) con[1].newInstance("小二",21);
			stu3 = (Student) con[2].newInstance("小一");
			stu4 = (Student) con[3].newInstance();
		}catch(Exception e)
		{
			e.printStackTrace();
		}
		System.out.println("对象信息1："+stu1);
		System.out.println("对象信息2："+stu2);
		System.out.println("对象信息3："+stu3);
		System.out.println("对象信息4："+stu4);
	}
}
/*
E:\javap>javac -d . Hi.java

E:\javap>java org.com.classdemo.Hi
0--------public org.com.classdemo.Student(int)
1--------public org.com.classdemo.Student(java.lang.String,int)
2--------public org.com.classdemo.Student(java.lang.String)
3--------public org.com.classdemo.Student()
对象信息1：姓名：null，年龄：20
对象信息2：姓名：小二，年龄：21
对象信息3：姓名：小一，年龄：0
对象信息4：姓名：小二，年龄：21
*/
// ==============
反射机制的应用
反射机制主要运用java.lang.reflect包，这个包常用的类有：
Constructor类：用于表示类中的构造方法
Field类：用于表示类中的成员属性
Method类：用于表示类中的成员方法
//获取类所实现的全部接口
package org.com.classdemo;
interface FirstInterface{}
interface SecondInterface{}
interface ThirdInterface{}
class Demo implements FirstInterface,SecondInterface,ThirdInterface
{

}
public class Hi
{
	public static void main(String[] args)
	{
		// 定义Class类型的数组
		Class<?> inter[] = null;
		try
		{
			// 获取全部实现的接口
			inter = Class.forName("org.com.classdemo.Demo").getInterfaces();
		}catch(ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		for(Class<?> c:inter)
		{
			System.out.println(c.getName());
		}
	}
}
/*
E:\javap>javac -d . Hi.java

E:\javap>java org.com.classdemo.Hi
org.com.classdemo.FirstInterface
org.com.classdemo.SecondInterface
org.com.classdemo.ThirdInterface
*/
// ==============
获取父类
通过 Class类的 getSuperclass()方法获取一个类的父类，再通过getName()方法返回父类的名称
package org.com.classdemo;
class SuperClass
{
	
}
class SubClass extends SuperClass
{
	
}
public class Hi
{
	public static void main(String[] args)
	{
		Class<?> c1 = null;
		Class<?> c2 = null;
		try
		{
			// 实例化 Class
			c1 = Class.forName("org.com.classdemo.SubClass");
			c2 = Class.forName("org.com.classdemo.SuperClass");
		}catch(ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		// 取得父类的名称
		System.out.println("SubClass的父类："+c1.getSuperclass().getName());
		System.out.println("SuperClass父类："+c2.getSuperclass().getName());
	}
}
/*
E:\javap>javac -d . Hi.java

E:\javap>java org.com.classdemo.Hi
SubClass的父类：org.com.classdemo.SuperClass
SuperClass父类：java.lang.Object
*/
// =============
访问成员变量
Class类中提供了一系列的方法可以访问类中的全部属性，
并返回Field对象或数组