Java - 反射机制(Reflection)

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");

     }

}