Java 之反射

标签：val   ops   china   直接   演示   获取文件   source   on()   return   

反射概述

反射概述：

• 反射（Reflection） 是被视为 动态语言 的关键，反射机制允许程序在执行期间借助于Reflection API 取得任何内部类的信息，并能直接操作任意对象的内部属性及方法。
• 加载完类之后，在堆内存的方法区中就产生了一个Class 类的对象（一个类只有一个Class 对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象的称之为 反射。

反射主要涉及到的包：

java.lang.Class
java.lang.reflect.Constructor;
java.lang.reflect.Field;
java.lang.reflect.Method;

反射演示

比如我们有一个 Person 类，如下代码演示如何动态获取 Person 类，并对其属性和方法进行操作。

@Test
    public void test1() throws Exception {
        Class clazz = Person.class;
        //1.通过反射，创建Person 类的对象
        Constructor cons = clazz.getConstructor(String.class, int.class);
        Object obj = cons.newInstance("Tom", 22);
        Person p = (Person) obj;
        System.out.println(p.toString());

        //2.通过反射，调用对象指定的属性、方法
        //调用属性，这里可以调用和设置私有属性
        Field age = clazz.getDeclaredField("age");
        //通过反射设置当前实例Person的age属性
        age.setAccessible(true);
        age.set(p, 10);

        //3.调用方法
        Method show = clazz.getDeclaredMethod("show");
        show.invoke(p);

        //4.调用私有方法,指定一个参数：
        Method showNation = clazz.getDeclaredMethod("showNation", String.class);
        showNation.setAccessible(true);//调用私有方法，必须去指定它的访问权限，权限为true，才可以调用该方法
        showNation.invoke(p, "China");

        //5.调用方法，带返回值的
        Method getName = clazz.getDeclaredMethod("getName");
        String name1 = (String) getName.invoke(p);//这里需要强转下返回值
        System.out.println(name1);

        //6.调用静态方法
        Method showDesc = clazz.getDeclaredMethod("showDesc", String.class);
        showDesc.setAccessible(true);
        Object returnVal = showDesc.invoke(Person.class, "Jerry description");//这里是void方法，所以返回值是null
        //Object returnVal = showDesc.invoke(null,"Jerry description");//或者填null也是可以的
        System.out.println("Return value is: " + returnVal);
    }

获取Class 的方式

• 有四种方式可以动态获取大Class

方式1：使用.class

//方式一：调用运行时的类的属性： .class
Class clazz1 = Person.class;
System.out.println(clazz1);

方式2：使用getClass()

//方式二：通过运行时类的对象，调用getClass()
Person p2 = new Person();
Class clazz2 = p2.getClass();
System.out.println(clazz2);

方式3：使用forName(String classPath)

//方式三：调用Class 的静态方法，forName(String classPath)
Class clazz3 = Class.forName("com.jerry.reflection1.Person");
System.out.println(clazz3);

方式4：使用ClassLoader

//方式四：使用ClassLoader（作为了解）
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class> clazz4 = classLoader.loadClass("com.jerry.reflection1.Person");
System.out.println(clazz4);

• 注意： 4种方式创建的实例对象，指向同一个实例

    System.out.println(clazz1 == clazz2);
    System.out.println(clazz1 == clazz3);
    System.out.println(clazz1 == clazz4);
  

理解java.lang.Class

类的加载过程：

• 程序通过javac.exe 命令以后，会生成一个或多个字节码文件(.class结尾的文件)，
  接着我们使用java.exe命令，对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程称为类的加载。
  加载到内存类中，我们就称为运行时类，此时运行时类，就作为Class 的一个实例。
• 简单来说：大Class 类其实就是对应运行时类的一个实例。
• 体现出：万事万物皆对象

可以获取Class 场景

• 可以动态获取 Class 实例的场景如下：

    @Test
    public void test3() throws Exception {
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = ElementType.class;
        Class c6 = Override.class;
        Class c7 = int.class;
        Class c8 = void.class;
        Class c9 = Class.class;
    
        int[] a = new int[10];
        int[] b = new int[100];
        Class c10 = a.getClass();
        Class c11 = b.getClass();
    
        //只要元素类型与维度一样，就是同一个Class
        System.out.println(c10 == c11);
    }
  

示例：反射文件获取内容

例如： 我们有一个jdbc.properties 的资源文件，如下：

我们要获取其中配置文件的 user 和 password 可以按如下办法：

方式1：FileInputStream

• 通过 FileInputStream 文件流的方式，获取配置文件中的内容

    Properties props = new Properties();
    //通过读取文件方式，获取配置文件中的内容，使用这种方式配置文件前面加src\  FileInputStream fis = new FileInputStream("src\\jdbc.properties");
    props.load(fis);
  
    String user = props.getProperty("user");
    String password = props.getProperty("password");
    System.out.println("User: " + user + " Password: " + password);
  

方式2：getClassLoader

• 通过反射 getClassLoader 在获取文件流方式，获取配置文件中内容

    //通过类的加载器获取资源文件中的内容,配置文件是在当前文件目录下
    Properties props = new Properties();
    ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    InputStream is = classLoader.getResourceAsStream("jdbc.properties");
    props.load(is);
    String user1 = props.getProperty("user");
    String password1 = props.getProperty("password");
    System.out.println("User1: " + user1 + " Password1: " + password1);
  

创建运行时类的对象

概述：我们通常需要根据反射，来动态的创建运行时类的对象，可以按如下方法：

@Test
public void test5() throws Exception {
    Class clazz = Person.class;
    Person person = clazz.newInstance();
    System.out.println(person);

    //这里是新创建的对象，所以不相等
    Person person1 = clazz.newInstance();
    Person person2 = clazz.newInstance();
    System.out.println(person1 == person2);//false
}

注意： newInstance() 方法调用时，对应实例类中必须有对应的空参构造器，没有的话就会报错

总结：要想此方法正常的创建运行时类的对象，要求：

• 1.运行时类必须提供空参的构造器
• 2.空参的构造器访问权限得够，通常为public

扩展：在javabean 中通常要求提供一个public 的空参构造器，好处如下：

• 1.便于通过反射，创建运行时类的对象
• 2.便于子类继承此运行类时，默认调用super() 时，保证父类有此构造器

示例：体会反射的动态性

@Test
public void test6() {

    for (int i = 0; i 

**总结： **上述代码，通过switch-case通过传入的 classPath 的 name 不同，既可以动态创建实例，这里就体现了反射的动态性。

附录：Person 类代码

public class Person {
    private String name;
    private int age;

    public Person() {
        System.out.println("Person constructor");
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name=‘" + name + ‘\‘‘ +
                ", age=" + age +
                ‘}‘;
    }

    public void show() {
        System.out.println("This is a person");
    }

    private void showNation(String nation) {
        System.out.println("My nation is : " + nation);
    }

    private static void showDesc(String desc) {
        System.out.println("My description is: " + desc );
    }
}

Java 之反射

标签：val   ops   china   直接   演示   获取文件   source   on()   return   

原文地址：https://www.cnblogs.com/vpersie2008/p/12831995.html