JAVA反射机制是在运行状态中，对于任意一个类 (class文件)，都能够知道这个类的所有属性和方法； 对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 动态获取类中信息，就是java反射 。可以理解为对类的解剖。要想要对字节码文件进行解剖，必须要有字节码文件对象.
如何获取字节码文件对象呢？
例：建bean包，包下面新建Person类
package bean;
public class Person {
private int age;
private String name;
public Person(String name,int age) {
super();
this.age = age;
this.name = name;
System.out.println("Person param run..."+this.name+":"+this.age);
}
public Person() {
super();
System.out.println("person run");
}
public void show(){
System.out.println(name+"...show run..."+age);
}
private void privateMethod(){
System.out.println(" method run ");
}
public void paramMethod(String str,int num){
System.out.println("paramMethod run....."+str+":"+num);
}
public static void staticMethod(){
System.out.println(" static method run......");
}
}
package Test28;
import bean.Person;
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
// TODO Auto-generated method stub
GetClassObject_1();
getClassObject_2();
getClassObject_3();
}
/**
* @throws ClassNotFoundException
* 方式三：
* 只要通过给定的类的字符串名称就可以获取该类，更为扩展。
* 可是用Class类中的方法完成，该方法就是forName。
* 这种方式只要有名称即可，更为扩展，扩展性更强。
*/
public static void getClassObject_3() throws ClassNotFoundException {
输出结果：
class bean.Person
String classNameString="bean.Person";
Class<?> class1=Class.forName(classNameString);
System.out.println(class1);
}
/**
* 方式二：
* 任何数据类型都具备一个静态的属性，class来获取其对应的class对象。
* 相对简单，但是还是要明确用到类中的静态成员，还是不够扩展。
*/
public static void getClassObject_2() {
Class clazz = Person.class;
输出结果：true
Class clazz1 = Person.class;
System.out.println(clazz == clazz1);
}
/**
* 方式一： 获取字节码对象的方式： 1、Object类中的getClass()方法的。想要用这种方式，必须明确具体的类，并创建对象
*/
输出结果：
person run
person run
true
public static void GetClassObject_1() {
Person person = new Person();
Class<? extends Person> clazzClass = person.getClass();
Person p1 = new Person();
Class<? extends Person> clazz1 = p1.getClass();
System.out.println(clazz1 == clazzClass);
}
}
例2：反射调用类的构造函数
package Test28;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
// createNewObject();
createNewObject_2();
}
/**
* 实例化无参的对象
*/
public static void createNewObject() throws ClassNotFoundException,
InstantiationException, IllegalAccessException {
// 早期，new的时候，先根据new的类的名称寻找该类的字节码文件，并加载进内存，
// 并创建该字节文件的对象，并接着创建该字节文件的对应的Person对象。
bean.Person person = new bean.Person();
// 现在：
String name = "bean.Person";
// 找寻该名称类的文件，并加载进内存，并产生Class对象。
Class<?> clazzClass = Class.forName(name);
// 创建该类的对象
Object object = clazzClass.newInstance();
System.out.println(object.toString());
}
/**
* @throws Exception
* 实例化有参对象
*/
public static void createNewObject_2() throws Exception {
// 以前实例化有参的类
bean.Person person = new bean.Person("小强", 39);
/*
* 当获取指定名称对应类中的所体现的对象时，
* 而该对象初始化不使用空参数构造该怎么办呢？
* 既然是通过指定的构造 函数进行对象的初始化，
* 所以应该先获取到该构造函数。 通过字节码文件对象即可完成。
* 该方法是：getConstructor(paramterTypes);
*/
String nameString = "bean.Person";
// 寻找该名称类文件，并加载进内存，并产生Class对象。
Class<?> class1 = Class.forName(nameString);
Constructor<?> constructor = class1.getConstructor(String.class,
int.class);
Object object = constructor.newInstance("小明", 32);
}
}
例3获取字节码文件中的字段。
package Test28;
import java.io.ObjectInputStream.GetField;
import java.lang.reflect.Field;
public class ReflectDemo3 {
public static void main(String[] args) throws ClassNotFoundException, Exception {
// TODO Auto-generated method stub
getFieldDemo();
}
/**
* @throws ClassNotFoundException
* @throws Exception
* 获取字节码文件中的字段。
*/
public static void getFieldDemo() throws ClassNotFoundException, Exception {
Class<?> class1=Class.forName("bean.Person");
Field field=null;
field=class1.getField("age");//只能获取公有的
field=class1.getDeclaredField("age");//只获取本类，但包含私有的。
field.setAccessible(true);//对私有字段的访问取消检查，暴力访问。
Object object=class1.newInstance();
field.set(object, 89);
Object o=field.get(object);
System.out.println(o);
}
}
例4获取字节码文件中的方法：
package Test28;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectDemo4 {
public static void main(String[] args) throws Exception {
// TODO Auto-generated method stub
getMethodDemo();
getMethod_2();
getMethodDemo_3();
}
public static void getMethod_2() throws Exception {
Class<?> class1 = Class.forName("bean.Person");
Method method = class1.getMethod("show", null);
Object object = class1.newInstance();
Constructor constructor = class1.getConstructor(String.class, int.class);
Object obj = constructor.newInstance("小明", 38);
method.invoke(obj, null);
}
/**
* @throws ClassNotFoundException
* 获取指定Class中的所有公共函数
*/
public static void getMethodDemo() throws ClassNotFoundException {
Class clazzClass = Class.forName("bean.Person");// 获取的都是公共方法
Method[] methods = clazzClass.getMethods();// 只获取本类中所有方法，包含私有。
for (Method method : methods) {
System.out.println(method);
}
}
public static void getMethodDemo_3() throws Exception,
IllegalArgumentException, InvocationTargetException {
Class<?> clazzClass = Class.forName("bean.Person");
Method method = clazzClass.getMethod("paramMethod", String.class,
int.class);
Object obj = clazzClass.newInstance();
method.invoke(obj, "小强", 89);
}
}
练习：模拟电脑运行
package cn.itcast.reflect.test;
public class Mainboard {
public void run() {
System.out.println("main board run....");
}
public void usePCI(PCI p) {//PCI p = new SouncCard();
if (p != null) {
p.open();
p.close();
}
}
}
package cn.itcast.reflect.test;
public interface PCI {
public void open();
public void close();
}
package cn.itcast.reflect.test;
public class NetCard implements PCI {
@Override
public void open() {
System.out.println("net open");
}
@Override
public void close() {
System.out.println("net close");
}
}
package cn.itcast.reflect.test;
public class SoundCard implements PCI {
public void open(){
System.out.println("sound open");
}
public void close(){
System.out.println("sound close");
}
}
package cn.itcast.reflect.test;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
/*
* 电脑运行。
*/
public class ReflectTest {
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
Mainboard mb = new Mainboard();
mb.run();
//每次添加一个设备都需要修改代码传递一个新创建的对象
// mb.usePCI(new SoundCard());
//能不能不修改代码就可以完成这个动作。
// 不用new来完成，而是只获取其class文件。在内部实现创建对象的动作。
File configFile = new File("pci.properties");
Properties prop = new Properties();
FileInputStream fis = new FileInputStream(configFile);
prop.load(fis);
for(int x=0; x<prop.size(); x++){
String pciName = prop.getProperty("pci"+(x+1));
Class clazz = Class.forName(pciName);//用Class去加载这个pci子类。
PCI p = (PCI)clazz.newInstance();
mb.usePCI(p);
}
fis.close();
}
}
