Java - 反射机制(Reflection)
> Reflection 是被视为 动态语言的关键，反射机制允许程序在执行期借助于 Reflection API 取得任何类的
内部信息，并能直接操作任意对象的内部属性及方法
> Java 反射机制提供的功能
> 在运行时判断任意一个对象所属的类
> 在运行时构造任意一个类的对象
> 在运行时判断任意一个类所具有的成员变量和方法
> 在运行时调用任意一个对象的成员变量和方法
> 生成动态代理
> 代码示例：
public class TestReflection {
//关于类的加载器：ClassLoader
@Test
public void test5() throws Exception{
ClassLoader loader1 = ClassLoader.getSystemClassLoader();
System.out.println(loader1);
ClassLoader loader2 = loader1.getParent();
System.out.println(loader2);
ClassLoader loader3 = loader2.getParent();
System.out.println(loader3);
Class clazz1 = Person.class;
ClassLoader loader4 = clazz1.getClassLoader();
System.out.println(loader4);
String className = "java.lang.String";
Class clazz2 = Class.forName(className);
ClassLoader loader5 = clazz2.getClassLoader();
System.out.println(loader5);
//掌握如下
//法一：
ClassLoader loader = this.getClass().getClassLoader();
InputStream is = loader.getResourceAsStream("com\atguigu\java\jdbc.properties");
//法二：
// FileInputStream is = new FileInputStream(new File("jdbc1.properties"));
Properties pros = new Properties();
pros.load(is);
String name = pros.getProperty("user");
System.out.println(name);
String password = pros.getProperty("password");
System.out.println(password);
}
//如何获取Class的实例（3种）
@Test
public void test4() throws ClassNotFoundException{
//1.调用运行时类本身的.class属性
Class clazz1 = Person.class;
System.out.println(clazz1.getName());
Class clazz2 = String.class;
System.out.println(clazz2.getName());
//2.通过运行时类的对象获取
Person p = new Person();
Class clazz3 = p.getClass();
System.out.println(clazz3.getName());
//3.通过Class的静态方法获取.通过此方式，体会一下，反射的动态性。
String className = "com.atguigu.java.Person";
Class clazz4 = Class.forName(className);
// clazz4.newInstance();
System.out.println(clazz4.getName());
//4.（了解）通过类的加载器
ClassLoader classLoader = this.getClass().getClassLoader();
Class clazz5 = classLoader.loadClass(className);
System.out.println(clazz5.getName());
System.out.println(clazz1 == clazz3);//true
System.out.println(clazz1 == clazz4);//true
System.out.println(clazz1 == clazz5);//true
}
/*
* java.lang.Class:是反射的源头。
* 我们创建了一个类，通过编译（javac.exe）,生成对应的.class文件。之后我们使用java.exe加载（JVM的类加载器完成的）
* 此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在在缓存区。那么这个运行时类本身就是一个Class的实例！
* 1.每一个运行时类只加载一次！
* 2.有了Class的实例以后，我们才可以进行如下的操作：
* 1）*创建对应的运行时类的对象
* 2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...）
* 3）*调用对应的运行时类的指定的结构(属性、方法、构造器)
* 4）反射的应用：动态代理
*/
@Test
public void test3(){
Person p = new Person();
Class clazz = p.getClass();//通过运行时类的对象，调用其getClass()，返回其运行时类。
System.out.println(clazz);
}
//有了反射，可以通过反射创建一个类的对象，并调用其中的结构
@Test
public void test2() throws Exception{
Class clazz = Person.class;
// Class clazz1 = String.class;
//1.创建clazz对应的运行时类Person类的对象
Person p = (Person)clazz.newInstance();
System.out.println(p);
//2.通过反射调用运行时类的指定的属性
//2.1
Field f1 = clazz.getField("name");
f1.set(p,"LiuDeHua");
System.out.println(p);
//2.2
Field f2 = clazz.getDeclaredField("age");
f2.setAccessible(true);
f2.set(p, 20);
System.out.println(p);
//3.通过反射调用运行时类的指定的方法
Method m1 = clazz.getMethod("show");
m1.invoke(p);
Method m2 = clazz.getMethod("display",String.class);
m2.invoke(p,"CHN");
}
//在有反射以前，如何创建一个类的对象，并调用其中的方法、属性
@Test
public void test1(){
Person p = new Person();
// Person p1 = new Person();
p.setAge(10);
p.setName("TangWei");
System.out.println(p);
p.show();
// p.display("HK");
}
}