Java中的反射Reflection
反射知识：
获取类型模板对象有三种方式：
1. 通过对象调用Object类中的getClass()方法来获取Class对象。
2. 利用Class类中的forName( String className)方法来获取class对象。
注：其中的className即为类全名（类全名 =包名.类名）。
3. 通过类型名来获取class对象。
代码如下：
package day11.javaAdvance.exercise.reflection.Class;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class ClassTest1 {
public static void main(String[] args) throws Exception {
/*
* 获取类型模板对象有三种方法：
*/
// 1.通过对象调用getClass方法获取Class对象
Student stu = new Student("wangwang", 4);
// 类型模板对象
Class c1 = stu.getClass();
System.out.println("1..." + c1);
System.out.println("^^^" + c1.getName());
// 2.利用Class对象来获取
Class c2 = Class.forName("day11.javaAdvance.exercise.reflection.Class.Student");//方法：forName("类全名");
System.out.println("2..." + c2);
// 3.通过类型名来获取
Class c3 = Student.class;
System.out.println("3..." + c3);
/*
* 获得此类的属性方法
*/
Field f[] = c1.getFields();
for (int i = 0; i < f.length; i++) {
System.out.println("属性有:" + f[i].getName());
}
}
}
class Student {
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
private void show() {
}
public void print() {
System.out.println("name=" + name + "," + "age=" + age);
}
}
通过反射方法动态来获取类中的方法和构造函数（五步）
1. 先获取类型模板对象：Class c=Student.class；
2. 通过类型模板对象来获取构造函数： Class arr[]={}; Constructor con=c.getDeclaredConstructor(arr);
3. 调用构造方法创建对象：Object obj1[]={}; Object obj=con.newInstance(obj1);
System.out.println(obj);
4. 获取方法：Method m=c.getMethod("show", arr);
5. 利用Mehtod对象调用方法invoke
Object o=m.invoke(obj, obj1);
package day11.javaAdvance.exercise.reflection.Class;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
/*
* 重点： 通过反射方法动态来获取类中的方法以及构造函数（五步）。
*/
public class ClassTest3 {
public static void main(String[] args) throws Exception {
// 1. 获得类型模板对象
Class cc = Studentd.class;
// 2.通过类型模板对象来获取构造方法
Class arrl[] = {};
// 在java.lang.reflect 类 Constructor<T>包中
Constructor cons = cc.getDeclaredConstructor(arrl);
// 3.调用构造方法创建实例
Object arr2[] = {};
Object obj1 = cons.newInstance(arr2);
System.out.println("%%% " + obj1);
// 4.获取方法
/*
* public Method getMethod(String name, Class<?>... parameterTypes)
*它反映此Class 对象所表示的类或接口的指定公共成员方法。
*/
Method m = cc.getMethod("show", arrl);
//5.invoke method 调用方法：
/*
*public Object invoke(Object obj,Object... args) 对带有指定参数的指定对象调用由此
* Method 对象表示的底层方法。
*/
Object obj = m.invoke(obj1, arr2);
Constructor[] con = cc.getConstructors();
for (int i = 0; i < con.length; i++) {
System.out.println("@@@ " + con[i]);
}
}
}
class Studentd {
public String name;
private int age;
public Studentd(String name, int age) {
this.name = name;
this.age = age;
}
public Studentd() {
}
public void show() {
System.out.println("~~~~呵呵.....");
}
private void show1() {
System.out.println("Hello!.....");
}
public void print() {
System.out.println("name=" + name + "," + "age=" + age);
}
}
package day11.javaAdvance.exercise.reflection.Class;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Properties;
public class ClassTest4 {
public static void main(String[] args) {
Biz1 b = new Biz1();
b.finteat();
}
}
class Biz1 {
Animal animal = (Animal) AnimalFactory.getObject("impl");
public void finteat() {
animal.eat();
}
}
class AnimalFactory {
static Properties pro = new Properties();
static {
try {
pro.load(new FileInputStream("config2.properties"));// 文件放在根目录下
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static Object getObject(String name) {
Object obj = null;
String className = pro.getProperty(name);// name即是key键值，className即是value值。
try {
Class c = Class.forName(className);
Class[] cl = {};
Constructor con = c.getDeclaredConstructor(cl);
Object[] obj1 = {};
obj = con.newInstance(obj1);
System.out.println("类全名是：" + obj);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return obj;
}
}
interface Animal1 {
public void eat();
}
class Dog1 implements Animal {
public void eat() {
System.out.println("dog eatting ....");
}
}
class Cat1 implements Animal {
public void eat() {
System.out.println("cat eatting....");
}
}
其中的配置文件在config2.properties文件中。
配置文件中是键值对，其中的key=impl，value分别是Dog1类和Cat1类，以类全名方式赋值。其内容是：
impl= day11.javaAdvance.exercise.reflection.Class.Dog1
#impl=day11.javaAdvance.exercise.reflection.Class.Cat1
这样我们只要传递键值，即可得到配置文件中的value值即是代码中的：String className = pro.getProperty(name);得到的className即是value值。
使用配置文件的好处：不需在源代码中去修改代码，只需在配置文件中修改，这样很好体现了java的封装性这一特点。
