Java-反射

概述

• JAVA反射机制是在运行状态中，对于任意一个类 (class文件)，都能够知道这个类的所有属性和方法；
  • 对于任意一个对象，都能够调用它的任意一个方法和属性；
  • 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
  • 动态获取类中信息，就是java反射 ，可以理解为对类的解剖。

原理

• 以Tomcat为例，它对外提供了一个接口是，servlet，我们在写程序的时候可以继承这个接口
• 可是我们怎么让Tomcat识别我们的程序那，在Tomcat里new 一个？
• 我们把我们程序的配置信息写在配置文件中，这样Tomcat就可以识别我们的程序了

反射机制

• 使用 Java 反射机制可以在运行时期检查 Java 类的信息，
• 检查 Java 类的信息往往是你在使用 Java 反射机制的时候所做的第一件事情
• 通过获取类的信息你可以获取以下相关的内容：

Class对象

• 要想要对字节码文件进行解剖，必须要有字节码文件对象，如何获取字节码文件对象呢？
• 第一种方式：
  • Object类中的getClass()方法的
  • 必须要明确具体的类，并创建对象，太麻烦

public static void getClassObject_1(){

    Person p = new Person();
    Class clazz = p.getClass();

    Person p1 = new Person();
    Class clazz1 = p1.getClass();

    System.out.println(clazz==clazz1);
}

• 第二种方式：
  • 任何数据类型都具备一个静态的属性.class来获取其对应的Class对象
  • 相对简单，但是还是要明确用到类中的静态成员，还是不够扩展

public static void getClassObject_2() {

    Class clazz = Person.class;
    Class clazz1 = Person.class;
    
    System.out.println(clazz==clazz1);
}

• 第三种方式
  • 可使用Class类中的 forName() 方法完成
  • 只要通过给定的类的 字符串名称就可以获取该类，更为方便，扩展性更强

public static void getClassObject_3() throws ClassNotFoundException {
		
    //类名记住一定要写全
    String className = "cn.java.bean.Person";
    Class clazz = Class.forName(className);

    System.out.println(clazz);
}

构造函数

• 早期：使用 new 的时候，先根据被new的类的名称找寻该类的字节码文件，并加载进内存，
• 并创建该字节码文件对象，并接着创建该字节文件的对应的Person对象

cn.java.bean.Person p = new cn.java.bean.Person();

• 现在：

String name = "cn.java.bean.Person";
//找寻该名称类文件，并加载进内存，并产生Class对象。
Class clazz = Class.forName(name);
//如何产生该类的对象呢？
Object obj  = clazz.newInstance();

• 当获取指定名称对应类中的所体现的对象时， 而该对象初始化不使用空参数构造该怎么办呢？
• 既然是通过指定的构造函数进行对象的初始化， 所以应该先获取到该构造函数。
• 通过字节码文件对象即可完成。
• 该方法是：getConstructor(paramterTypes);

String name = "cn.java.bean.Person";
//找寻该名称类文件，并加载进内存，并产生Class对象。
Class clazz = Class.forName(name);
//获取到了指定的构造函数对象。
Constructor constructor = clazz.getConstructor(String.class,int.class);

//通过该构造器对象的newInstance方法进行对象的初始化。
Object obj = constructor.newInstance("小明",38);

字段

public static void getFieldDemo() throws Exception {
		
    Class clazz = Class.forName("cn.java.bean.Person");

    Field field = null;//clazz.getField("age");//只能获取公有的，

    field = clazz.getDeclaredField("age");//只获取本类，但包含私有。 

    //对私有字段的访问取消权限检查。暴力访问。
    field.setAccessible(true);

    Object obj = clazz.newInstance();

    field.set(obj, 89);

    Object o = field.get(obj);
    System.out.println(o);
    //上述语句，和下面语句实现了一样的功能
	//cn.java.bean.Person p = new cn.itcast.bean.Person();
	//p.age = 89;
}

方法

• 获取指定Class中的所有公共函数

public static void getMethodDemo() throws Exception {
		
    Class clazz = Class.forName("cn.itcast.bean.Person");
    
    Method[] methods  = clazz.getMethods();//获取的都是公有的方法。 
    methods = clazz.getDeclaredMethods();//只获取本类中所有方法，包含私有。 
    for(Method method : methods){
        System.out.println(method);
    }
}

• 获取指定Class中的指定空参方法

public static void getMethodDemo_2() throws Exception {
		
    Class clazz = Class.forName("cn.itcast.bean.Person");

    Method method = clazz.getMethod("show", null);//获取空参数一般方法。

    Constructor constructor = clazz.getConstructor(String.class,int.class);
    Object obj = constructor.newInstance("小明",37);

    method.invoke(obj, null);

}

• 获取指定Class中指定有参方法

public static void getMethodDemo_3() throws Exception {
		
	Class clazz = Class.forName("cn.itcast.bean.Person");

	Method method = clazz.getMethod("paramMethod", String.class,int.class);
	
	Object obj = clazz.newInstance();

	method.invoke(obj, "小强",89);

}

演示类（Person）

package cn.java.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......");
	}
}

练习

• 需求：简易模拟电脑运行，需要声卡和网卡
• 因为后期可能有各种设备，所以创建接口，让设备继承接口

//接口
public interface PCI {
	public void open();
	public void close();
}

public class SoundCard implements PCI {
	public void open(){
		System.out.println("sound open");
	}
	public void close(){
		System.out.println("sound close");
	}
}

public class NetCard implements PCI {

	public void open() {
		System.out.println("net open");
	}

	public void close() {
		System.out.println("net close");
	}
}

• 模拟主板

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();
		}
	}
}

• 每次添加设备都要修改代码传递新对象吗？可以不修改代码完成该动作吗？
• 创建一个配置文件，包含着各设备信息，主类中调取并实现创建对象的动作

public class ReflectTest {

	/**
	 * @param args
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {

		Mainboard mb = new Mainboard();
		mb.run();
		
		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的对象
			PCI p = (PCI)clazz.newInstance();
			
			mb.usePCI(p);
		}
		fis.close();	
	}
}