Class类是整个反射的操作源头
定义：在运行状态时(动态的)，对于任意一个类，都能够得到这个类的所有属性和方法。
对于任意一个对象，都能够调用它的任意属性和方法。
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.
反射就是把java类中的各种成分映射成一个个的Java对象。
1.通过反射获取构造方法并使用：
package a01;
public class a03a {
//通过反射获取构造方法并使用：
a03a(String str)
{
System.out.println("默认的构造方法 method="+str);
}
public a03a()
{
System.out.println("调用了公有无参的构造方法");
}
public a03a(char name)
{
System.out.println("姓名："+name);
}
public a03a(String name,int age)
{
System.out.println("姓名："+name+"年龄："+age);
}
protected a03a(boolean n)
{
System.out.println("受保护的构造方法 n="+n);
}
private a03a(int age)
{
System.out.println("私有构造方法 年龄："+age);
}
}
package a01;
import java.lang.reflect.Constructor;
public class a03b{
public static void main(String[] args) throws Exception {
Class clazz=Class.forName("a01.a03a");
/*
a03a a1=new a03a();
Class clazz=a1.getClass();
可以使用这种构造方法代替上面的方法
*/
System.out.println("------所有公有构造方法------");
Constructor[] con = clazz.getConstructors();
for(int j=0;j<con.length;j++) {
System.out.println(con[j]);}
System.out.println("------所有的构造方法(包括：私有、受保护、默认、公有)------");
con=clazz.getDeclaredConstructors();
for(int j=0;j<con.length;j++) {
System.out.println(con[j]);}
System.out.println("------获取公有、无参的构造方法------");
Constructor conn = clazz.getConstructor(null);
System.out.println("con="+con);
Object obj=conn.newInstance();
System.out.println("------获取私有构造方法，并调用------");
conn = clazz.getDeclaredConstructor(char.class);
System.out.println(char.class);
conn.setAccessible(true);//强制访问
obj=conn.newInstance('男');
}
}
2.获取成员变量并调用：
package a01;
public class a04a {
//获取成员变量并调用
public a04a()
{
}
public String name;
protected int age;
char sex;
private String phoneNum;
public String toString()
{
return "Student [name=" + name + ", age=" + age + ", sex=" + sex
+ ", phoneNum=" + phoneNum + "]";
}
}
package a01;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class a04b {
public static void main(String[] args) throws Exception {
Class sclass=Class.forName("a01.a04a");
/*
a04a a1=new a04a();
Class sclass=a1.getClass();
可以使用这种构造方法代替上面的方法
*/
System.out.println("------获取所有的公有子段------");
Field[] field=sclass.getFields();
for(int j=0;j<field.length;j++) {
System.out.println(field[j]);}
System.out.println("------获取所有的字段(包括私有、受保护、默认的)------");
field = sclass.getDeclaredFields();
for(Field f : field){
System.out.println(f);}
System.out.println("------获取公有字段并调用------");
Field f = sclass.getField("name");
System.out.println(f);
Object obj=sclass.getConstructor().newInstance();
f.set(obj,"沈腾");
a04a aa=(a04a)obj;
System.out.println("验证姓名：" + aa.name);
System.out.println("------获取私有字段并调用------");
f=sclass.getDeclaredField("phoneNum");
System.out.println(f);
f.setAccessible(true);
f.set(obj,"1789749845");
System.out.println("验证电话："+aa);
}
}
3.获取成员方法并调用：
package a01;
public class a05a {
//获取成员方法并调用
public void show1(String s){
System.out.println("调用了：公有的，String参数的show1(): s = " + s);
}
protected void show2(){
System.out.println("调用了：受保护的，无参的show2()");
}
void show3(){
System.out.println("调用了：默认的，无参的show3()");
}
private String show4(double age){
System.out.println("调用了，私有的，并且有返回值的，int参数的show4(): age = " + age);
return "abcd";
}
}
package a01;
import java.lang.reflect.Method;
public class a05b {
public static void main(String[] args) throws Exception {
Class sclass=Class.forName("a01.a05a");
/*a05a a1=new a05a();
Class sclass=a1.getClass();
可以使用这种构造方法代替上面的方法
*/
System.out.println("------获取所有的”公有“方法------");
sclass.getMethods();
Method[] method=sclass.getMethods();
for(int j=0;j<method.length;j++) {
System.out.println(method[j]);}
System.out.println("------获取所有的方法，包括私有的------");
method = sclass.getDeclaredMethods();
for(Method m : method){
System.out.println(m);
}
System.out.println("------获取公有的show1()方法------");
Method m = sclass.getMethod("show1", String.class);
System.out.println(m);
//实例化一个Student对象
Object obj = sclass.getConstructor().newInstance();
m.invoke(obj,"沈腾");
System.out.println("------获取私有的show4()方法------");
m=sclass.getDeclaredMethod("show4",double.class);
System.out.println(m);
m.setAccessible(true);
Object result=m.invoke(obj,20.0);
System.out.println("返回值：" + result);
}
}
4.反射main方法
package a01;
public class a06a {
public static void main(String[] args)
{
System.out.println("执行main方法");
}
}
package a01;
import java.lang.reflect.Method;
public class a06b {
public static void main(String[] args) {
// TODO Auto-generated method stub
try {
Class sclass=Class.forName("a01.a06a");
/*a06a a1=new a06a();
Class sclass=a1.getClass();*/
Method methodMain=sclass.getMethod("main",String[].class);
Object invoke = methodMain.invoke(null,(Object)new String[]
{"a"});
}catch(Exception e)
{
e.printStackTrace();
}
}
}
5.反射配置文件
配置文件：dem.TXT
className = a01.a07a
methodName = show
package a01;
public class a07a {
public void show()
{
System.out.println("show()");
}
}
package a01;
import java.io.FileReader;
import java.lang.reflect.Method;
import java.util.Properties;
/*
className = a01.a07a
methodName = show
*/
public class a07b {
public static String getValue(String key) throws Exception{
Properties pp=new Properties();//获取配置文件的对象
FileReader in=new FileReader("F:\\1若干文档\\dem.TXT");
pp.load(in);
in.close();
return pp.getProperty(key);
}
public static void main(String[] args) throws Exception, Exception {
// TODO Auto-generated method stub
Class stuClass=Class.forName(getValue("className"));
Method m=stuClass.getMethod(getValue("methodName"));
m.invoke(stuClass.getConstructor().newInstance());
}
}