黑马程序员——JAVA基础---反射

最新推荐文章于 2020-05-23 17:22:39 发布

原创最新推荐文章于 2020-05-23 17:22:39 发布 · 414 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

JAVA学习笔记专栏收录该内容

11 篇文章

订阅专栏

本文深入讲解Java反射机制的基础原理及应用方法，包括如何通过Class对象获取构造方法、成员方法及成员变量等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ——-

java的反射机制：

  我们都知道，一个java类中，有成员变量、成员方法、构造方法等等，反射机制，就是动态的获取这些类中的信息，并动态的调用对象的方法。通常只有要设计框架的过程中，才会使用java反射相关的api，但是了解java反射机制的基本原理与基本方法，可以帮忙我们在日后对框架的学习与应用提供很大的帮忙。

 了解Class类：
      Class类代表着某个类的字节码，要使用反射，就需要取得对应的Class对象，然后就通过这个对象，就可解剖出类的成员变量，成员方法等等。

Class类的常用方法：
getConstructor() 获取构造函数
getMethod() 获取成员方法
getField() 获取成员变量

getDeclaredConstructor() 获取私有的构造函数
getDeclaredMethod() 获取私有的成员方法
getDeclaredField() 获取私有的成员变量

一如何获取JAVA对象

[java]
//通过Class的forName()方法,此方法最为常用
Class class1 = Class.forName(“com.java4fun.reflect.Person”);
//通过 Person.class
Class class2 = Person.class;
//通过对象获得
Class class3 = new Person().getClass();

反射的使用，简单的讲，就是通过类的Class对象，获取对应的Field、Method 和 Constructor 对象，并进行相关操作。
下面就用反射来解剖Person类，给出Person类：

 public class Person {  

    public String name = "java";  
    private int age = 2013;  

    //无参构造函数  
    public Person() {  
    }  

    public Person(int age) {  
        super();  
        this.age = age;  
    }  
    //私有构造函数  
    private Person(String name) {  
        super();  
        this.name = name;  
    }  

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

    public int getAge() {  
        return age;  
    }  

    public String getName() {  
        return name;  
    }  

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

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

    public static void getMessage(String message){  
        System.out.println(message);  
    }  

    public static void getFriends(String friends[]){  
        for(String s:friends){  
            System.out.print(s+"\t");  
        }  
    }  

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

    private void secret(String secret){  
        System.out.println(secret);  
    }  

    public void run(int num){  
        System.out.println(num);  
    }  
}

二构造函数的获取：

 import java.lang.reflect.Constructor;  

public class ConstructorTest {  
    // 利用反射技术，完成对Person.类的相关操作  
    public static void main(String[] args) throws Exception {  
         constructor1(); //无参构造函数的获取与使用  
         constructor2(); // 带参数的构造函数的获取使用  
         constructor3(); // 私有的构造函数的获取使用  
    }  

    // 获取私有构造函数  
    private static void constructor3() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取私有构造函数对象。  
        Constructor c = clazz.getDeclaredConstructor(String.class);  
        // 由于私有的构造函数无数直接构造对象,需要调用setAccessible()，  
        //此方法来自于AccessibleObject 类，它是 Field、Method 和 Constructor 对象的基类  
        c.setAccessible(true);  
        // 利用这个构造函数，构造一个Person对象  
        Person p = (Person) c.newInstance("private constructor");  
        System.out.println(p);  
    }  

    // 访问带参数的构造函数  
    private static void constructor2() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取带参数的构造函数对象。  
        Constructor c = clazz.getConstructor(String.class, int.class);  
        // 利用这个构造函数，构造一个Person对象  
        Person p = (Person) c.newInstance("hello", 110);  
        System.out.println(p);  
    }  

    // 访问无参构造函数  
    private static void constructor1() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取无参的构造函数对象。  
        Constructor c = clazz.getConstructor(null);  
        // 利用这个构造函数，构造一个Person对象  
        Person p = (Person) c.newInstance(null);  
        System.out.println(p);  

        // Class类也提供了一个可直接用无参构造函数构造对象的方法  
        // Person person = (Person) clazz.newInstance();  
        // System.out.println(person);  
    }  
}

三成员方法的获取：


import java.lang.reflect.Method;  

public class MethodTest {  
    // 利用反射技术，完成对Person.类的相关操作  
    public static void main(String[] args) throws Exception {  
         //method1(); //无参成员方法的获取与使用  
        // method2(); // 带参数成员方法的获取使用  
         //method3(); // 私有成员方法的获取使用  
        method4(); // 参数是数组的方法解决方法  
    }  

    // 获取无参成员方法  
    private static void method1() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取无参的方法， 反射Person类的中 public String getName(){}方法  
        Method m = clazz.getMethod("getName", null);  
        //运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。  
        Person p = new Person("HelloWorld",23);  
        String name = (String) m.invoke(p, null);  
        System.out.println(name);  
    }  

    // 获取带参数的成员方法  
    private static void method2() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取带参数的方法， 反射Person类的中 public void run(int num){}方法  
        Method m = clazz.getMethod("run", int.class);  
        //运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。  
        Person p = new Person("HelloWorld",23);  
        m.invoke(p, 11111);  
    }  

    // 获取私有的成员方法  
    private static void method3() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获私有的方法， 反射Person类的中 private void secret(String secret){}方法  
        Method m = clazz.getDeclaredMethod("secret", String.class);  
        //让私有方法可以访问  
        m.setAccessible(true);  
        //运行这个方法,由于方法的运行需要对象，为了方便，在这里直接通过传统的方法创建一个对象。  
        Person p = new Person("HelloWorld",23);  
        m.invoke(p, "最近变胖了");  
    }  

    // 参数是数组的方法解决方法  
    private static void method4() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获静态方法， 反射Person类的中 public static void getFriends(String friends[]){}方法  
        Method m = clazz.getMethod("getFriends", String[].class);  

        //这样调用方法会出错，由于版本的遗留问题，new String[]{"java","c","c++"}会被认为是"java" "c"  "c++"  
        //m.invoke(null, new String[]{"java","c","c++"});  
        //相当于getFriends("java","c","c++");  

        //正确调用方法,相当于把数组当成一个对象传入  
        m.invoke(null, (Object)new String[]{"java","c","c++"});  
    }  
}

四成员属性的获取：


import java.lang.reflect.Field;  

public class FieldTest {  
    // 利用反射技术，完成对Person.类的相关操作  
    public static void main(String[] args) throws Exception {  
         method1(); // 获取属性  
         method2(); // 获取私有属性  
    }  

    // 获取属性  
    private static void method1() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取属性， 反射Person类的中 public String name = "java";属性  
        Field f = clazz.getField("name");  
        // 使用属性，需指定对象,为了方便，在这里直接通过传统的方法创建一个对象。  
        Person p = new Person();  
        Class type = f.getType();  
        if (type.equals(String.class)) {  
            String name = (String) f.get(p);  
            System.out.println(name);  
        }  
    }  

    // 获取私有属性    
    private static void method2() throws Exception {  
        // 获取Person的字节码对象。  
        Class clazz = Class.forName("com.java4fun.reflect.Person");  
        // 获取私有属性， 反射Person类的中 private int age = 2013;属性  
        Field f = clazz.getDeclaredField("age");  
        f.setAccessible(true);  
        // 使用属性，需指定对象,为了方便，在这里直接通过传统的方法创建一个对象。  
        Person p = new Person();  
        Class type = f.getType();  
        if (type.equals(int.class)) {  
            int age = f.getInt(p);  
            System.out.println(age);  
        }  
    }  
}