86 java反射_2 _反射的常见操作

原创 于 2020-07-26 08:45:48 发布 · 224 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #反射

本文深入解析Java反射机制，涵盖其核心功能、应用场景及代码实践。介绍如何动态获取类信息、构造对象、调用方法和访问属性，展示反射在解决私有成员访问限制问题上的应用。

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

文章目录

反射

  • **JAVA反射机制**是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

  • 反射被视为动态语言的关键。

  • Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

  • 反射机制：反射这一概念最早由编程开发人员Smith在1982年提出，主要指应用程序访问、检测、修改自身状态与行为的能力。这一概念的提出立刻吸引了编程界的极大关注，各种研究工作随之展开，随之而来引发编程革命，出现了多种支持反射机制的面向对象语言。 在计算机科学领域，反射是指一类能够自我描述和自控制的应用。在Java编程语言中，反射是一种强有力的工具，是面向抽象编程一种实现方式，它能使代码语句更加灵活，极大提高代码的运行时装配能力。

  • 用途：在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。当然，也不是所有的都适合反射，之前就遇到一个案例，通过反射得到的结果与预期不符。阅读源码发现，经过层层调用后在最终返回结果的地方对应用的权限进行了校验，对于没有权限的应用返回值是没有意义的缺省值，否则返回实际值起到保护用户的隐私目的。

反射常用方法

  • public String getName ()
  • public Package getPackage ()
  • public Class<? super T> getSuperclass () //父类
  • public Class<?>[] getInterfaces () //接口
  • public Constructor<?>[] getConstructors () //构造方法
  • public T newInstance () //新建一个实例
  • public Method[] getMethods ()
  • public Field[] getFields () //字段 ，属性

反射常见操作

package com.wlw.chapter12_reflex;

import java.io.Serializable;

public class Person implements Serializable, Cloneable {
    String name;
    int age;

    public Person() {
        System.out.println("无参构造方法执行了.........");
    }

    public Person(String name, int age) {
        System.out.println("带参构造方法执行了........");
        this.name = name;
        this.age = age;
    }

    public void eat(){
        System.out.println(this.name+"正在吃饭");
    }
    
      @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
常见操作代码1：
package com.wlw.chapter12_reflex;

import java.util.Arrays;

public class TestPerson {
    public static void main(String[] args) throws Exception {     
        reflectOpe1();
    }
    //1. 使用反射获取类的名字，包名，父类，接口
    public static void reflectOpe1() throws Exception {
        //1.第一步先获取类对象
        Class<?> class1= Class.forName("com.wlw.chapter12_reflex.Person");
        //2.获取
        //public String getName () 类的名字
        System.out.println(class1.getName());//com.wlw.chapter12_reflex.Person
        
        //public Package getPackage () 包名
        System.out.println(class1.getPackage().getName());//com.wlw.chapter12_reflex
        
        //public Class<? super T> getSuperclass () //父类
        System.out.println(class1.getSuperclass().getName());//java.lang.Object
        
        //public Class<?>[] getInterfaces () //接口
        Class<?>[] classes = class1.getInterfaces();
        System.out.println(Arrays.toString(classes));

        System.out.println(class1.getSimpleName()); //Person
        System.out.println(class1.getTypeName()); //com.wlw.chapter12_reflex.Person
    }
}
/* 执行结果：
com.wlw.chapter12_reflex.Person
com.wlw.chapter12_reflex
java.lang.Object
[interface java.io.Serializable, interface java.lang.Cloneable]
Person
com.wlw.chapter12_reflex.Person

*/
常见操作代码2：

getConstructor(参数的类型 <可选>); newInstance(具体参数值 <可选>)

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.util.Arrays;

public class TestPerson {
    public static void main(String[] args) throws Exception {
        reflectOpe2();
    }

    //2. 使用反射获取类的构造方法，并创建对象（不是new）
    public static void reflectOpe2() throws Exception {
        //1.第一步先获取类对象
        Class<?> class1= Class.forName("com.wlw.chapter12_reflex.Person");
        //2.获取类的构造方法  getConstructors
        Constructor<?>[] constructors = class1.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println(constructor.toString());
        }
        
        //3.获取无参构造
        Constructor<?> con = class1.getConstructor();
        Person zhangsan = (Person) con.newInstance();//这里就是调用无参构造方法
        System.out.println(zhangsan.toString());
        // 简便方法
        Person lisi = (Person) class1.newInstance();//上面的简化
        System.out.println(lisi.toString());

        //4.获取有参构造
        Constructor<?> con2 = class1.getConstructor(String.class, int.class);
        Person wangwu = (Person)con2.newInstance("王五", 20);
        System.out.println(wangwu.toString());


    }
}
/* 执行结果：
public com.wlw.chapter12_reflex.Person()
public com.wlw.chapter12_reflex.Person(java.lang.String,int)
无参构造方法执行了.........
Person{name='null', age=0}
无参构造方法执行了.........
Person{name='null', age=0}
带参构造方法执行了........
Person{name='王五', age=20}
*/
常见操作代码3：

获取单个方法getMethod(“方法名”,参数的类型); 之后调用invoke(类的一个对象,具体参数值)

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;

public class TestPerson {
    public static void main(String[] args) throws Exception {
        reflectOpe3();
    }
    //3. 使用反射获取类的方法
    public static void reflectOpe3() throws Exception{
        //1.第一步先获取类对象
        Class<?> class1= Class.forName("com.wlw.chapter12_reflex.Person");

        //2.获取类的方法
        //2.1  getMethods () 获得的是公共的方法，包括从父类继承的方法
       /* Method[] methods = class1.getMethods();
        for (Method method : methods) {
            System.out.println(method.toString());
        }*/
        //2.2getDeclaredMethods() 获得的是类中所有的方法，包括私有，保护，默认，不包括继承的方法
        /*Method[] declaredMethods = class1.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.toString());
        }*/

        //3 获取单个方法getMethod("方法名",参数);  调用invoke(类的一个对象,参数)
        //3.1 无参eat()
        Method eatMethod = class1.getMethod("eat");
        //正常调用方法：Person zhangsan = new Person(); zhangsan.eat();
        //调用invoke(类的一个对象,参数)
        Constructor<?> constructor = class1.getConstructor(String.class, int.class);
        Person xiaowang = (Person) constructor.newInstance("小王", 20);//调用的是有参构造
        eatMethod.invoke(xiaowang); //zhangsan.eat();
        System.out.println("----------------------------");

        //3.2 toString
        Method toStringMethod = class1.getMethod("toString");
        Object result = toStringMethod.invoke(xiaowang);
        System.out.println(result);
        System.out.println("----------------------------");

        //3.3带参eat()
        Method eatMethod2 = class1.getMethod("eat", String.class);
        eatMethod2.invoke(xiaowang,"鸡腿");
        System.out.println("----------------------------");

        //3.4 私有方法 privateMethod
        Method privateMethod = class1.getDeclaredMethod("privateMethod");
        //私有方法 需要设置访问权限无效
        privateMethod.setAccessible(true);
        privateMethod.invoke(xiaowang);
        System.out.println("----------------------------");

        //3.5 静态方法staticMethod
        Method staticMethod = class1.getMethod("staticMethod");
        staticMethod.invoke(null);//这个也行 调用静态方法
        staticMethod.invoke(xiaowang);
    }
}
/* 执行结果：
带参构造方法执行了........
小王正在吃饭
----------------------------
Person{name='小王', age=20}
----------------------------
小王正在吃 鸡腿
----------------------------
这是一个私有方法
这是一个静态方法
这是一个静态方法
*/
常见操作代码4：

使用反射实现 一个方法 可以调用任意对象方法的通用方法

package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Properties;

public class TestPerson {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        //properties.setProperty("name","zhangsan");
        //System.out.println(properties.toString());
        invokeAny(properties,"setProperty", new Class[] {String.class,String.class},"name","zhangsan");
        System.out.println(properties.toString());
    }

    //4.使用反射实现 一个方法 可以调用任意对象方法的通用方法
    public static Object invokeAny(Object object,String methodName,Class<?>[] type,Object...args ) throws Exception {
        //1.获取类对象
        Class<?> class1 = object.getClass();
        //2.获取方法
        Method method = class1.getMethod(methodName,type);
        //调用
        return  method.invoke(object,args);
    }
}
/*执行结果：
{name=zhangsan}
*/
常见操作代码5：
package com.wlw.chapter12_reflex;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Properties;

public class TestPerson {
    public static void main(String[] args) throws Exception {
        reflectOpe4();
    }
    //5. 使用反射获取类的属性 字段
    public static void reflectOpe4() throws Exception{
        //1.获取类对象
        Class<?> class1 = Class.forName("com.wlw.chapter12_reflex.Person");

        //2.获取属性 getFields() 只能获取公共的，和继承父类的；
        //Field[] fields = class1.getFields();
        // getDeclaredFields()  获得的是类中所有的属性，包括私有，保护，默认的
 //       Field[] fields = class1.getDeclaredFields();
 //       for (Field field : fields) {
 //           System.out.println(field.toString());
 //        }


        //3.获取单个的属性
        //正常赋值：Person zhangsan = new Person(); zhangsan.name = "张三";
        Field namefiled = class1.getDeclaredField("name");
        //namefiled.setAccessible(true);  //属性私有的话，要设置访问权限无效
        //赋值
        Person zhangsan = (Person)class1.newInstance(); //Person zhangsan = new Person();
        namefiled.set(zhangsan,"张三");//zhangsan.name = "张三";
        //获取值
        System.out.println(namefiled.get(zhangsan)); //zhangsan.name
    }
}
/*执行结果：
无参构造方法执行了.........
张三
*/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

悬浮海

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值