java反射

最新推荐文章于 2024-03-07 10:15:07 发布
最新推荐文章于 2024-03-07 10:15:07 发布
阅读量201 收藏
点赞数 1
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huzi99/article/details/104195761
版权

* 框架：半成品软件。可以在框架的基础上进行软件开发，简化编码

* 反射：将类的各个组成部分封装为其他对象，这就是反射机制
        * 好处：
            1. 可以在程序运行过程中，操作这些对象。
            2. 可以解耦，提高程序的可扩展性。

 获取Class对象的方式：                                
        1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
            * 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
        2. 类名.class：通过类名的属性class获取
            * 多用于参数的传递
        3. 对象.getClass()：getClass()方法在Object类中定义着。
            * 多用于对象的获取字节码的方式

        * 结论：
            同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个。

 

代码：domain.Person类

package com.tiger.domain;

/**
 * power by tigerchen
 */
public class Person {
    private String name;
    private int age;
    public String a;
    protected String b;
    String c;
    private String d;

    public Person() {

    }

    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;
    }

    public String getA() {
        return a;
    }

    public void setA(String a) {
        this.a = a;
    }

    public String getB() {
        return b;
    }

    public void setB(String b) {
        this.b = b;
    }

    public String getC() {
        return c;
    }

    public void setC(String c) {
        this.c = c;
    }

    public String getD() {
        return d;
    }

    public void setD(String d) {
        this.d = d;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat()
    {
        System.out.println("eat....");
    }
    public void eat(String food){
        System.out.println("eat..."+food);
    }
}

Student类


package com.tiger.domain;

/**
 * power by tigerchen
 */
public class Student {
    public void sleep(){
        System.out.println("sleep");
    }
}

获取Class对象的方式的代码

package com.tiger.reflect;

import com.tiger.domain.Person;

/**
 * power by tigerchen
 */
public class reflectDemo1 {
    /**
     获取Class对象的方式：
     1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
     2. 类名.class：通过类名的属性class获取
     3. 对象.getClass()：getClass()方法在Object类中定义着。
     */
    public static void main(String[] args) throws Exception {
        //Class.forname(“全類名”)
        Class aClass1 = Class.forName("com.tiger.domain.Person");
        System.out.println(aClass1);
        //类名.class：通过类名的属性class获取
        Class personClass = Person.class;

        System.out.println(personClass);
        //对象.getClass()：getClass()方法在Object类中定义着。
        Person person = new Person();

        Class aClass2 = person.getClass();
        System.out.println(aClass2);
        System.out.println(aClass1==aClass2);
        System.out.println(aClass1==personClass);
    }
}

* Class对象功能：
        * 获取功能：
            1. 获取成员变量们
                * Field[] getFields() ：获取所有public修饰的成员变量
                * Field getField(String name)   获取指定名称的 public修饰的成员变量

                * Field[] getDeclaredFields()  获取所有的成员变量，不考虑修饰符
                * Field getDeclaredField(String name)  
            2. 获取构造方法们
                * Constructor<?>[] getConstructors()  
                * Constructor<T> getConstructor(类<?>... parameterTypes)  

                * Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)  
                * Constructor<?>[] getDeclaredConstructors()  
            3. 获取成员方法们：
                * Method[] getMethods()  
                * Method getMethod(String name, 类<?>... parameterTypes)  

                * Method[] getDeclaredMethods()  
                * Method getDeclaredMethod(String name, 类<?>... parameterTypes)  

            4. 获取全类名    
                * String getName() 

获取成员变量

* Field：成员变量
        * 操作：
            1. 设置值
                * void set(Object obj, Object value)  
            2. 获取值
                * get(Object obj)

            3. 忽略访问权限修饰符的安全检查
                * setAccessible(true):暴力反射

package com.tiger.reflect;

import com.tiger.domain.Person;

import java.lang.reflect.Field;

/**
 * power by tigerchen
 */
public class reflectDemo2 {

    public static void main(String[] args) throws Exception {
        //0.获取Person的Class对象
        Class personClass = Person.class;
        //Field[] field獲取到所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        /*
        1. 设置值
				* void set(Object obj, Object value)
			2. 获取值
				* get(Object obj)

			3. 忽略访问权限修饰符的安全检查
				* setAccessible(true):暴力反射
         */
        //public
        Field a = personClass.getField("a");
        System.out.println(a);
        Person person = new Person();
        Object o = a.get(person);
        System.out.println("获取name的值"+o);
        a.set(person,"cftiegr");
        System.out.println("整个对象的值"+person);
        Object o1 = a.get(person);
        System.out.println("再次获取name:"+o1);

        //所有的
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        Field age = personClass.getDeclaredField("age");
        System.out.println("获取年龄"+age);
        //忽略访问权限修饰符的安全检查
        age.setAccessible(true);//暴力反射
        Object o2 = age.get(person);
        System.out.println(o2);

    }
}

* Constructor:构造方法
        * 创建对象：
            * T newInstance(Object... initargs)  

            * 如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法

package com.tiger.reflect;

import com.tiger.domain.Person;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * power by tigerchen
 */
public class reflectDemo3 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class personClass = Person.class;
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //创建对象
        Object value = constructor.newInstance("张三", 8);
        System.out.println(value);
        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //创建对象
        Object person = constructor1.newInstance();
        System.out.println(person);
    }
}

* Method：方法对象
        * 执行方法：
            * Object invoke(Object obj, Object... args)  

        * 获取方法名称：
            * String getName:获取方法名

package com.tiger.reflect;

import com.tiger.domain.Person;

import java.lang.reflect.Method;

/**
 * power by tigerchen
 */
public class reflectDemo4 {
    public static void main(String[] args) throws Exception {
        Class personClass = Person.class;
        //获取所有public方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        //获取类名
        String name = personClass.getName();
        System.out.println(name);
        //获取指定名称的方法
        Method eat = personClass.getMethod("eat");
        System.out.println(eat);
        Person person = new Person();
        //执行方法
        eat.invoke(person);
        Method eat1 = personClass.getMethod("eat", String.class);
        eat1.invoke(person,"👨粑粑");
    }
}

动态代理

* 案例：
        * 需求：写一个"框架"，不能改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
            * 实现：
                1. 配置文件
                2. 反射
            * 步骤：
                1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
                2. 在程序中加载读取配置文件
                3. 使用反射技术来加载类文件进内存
                4. 创建对象
                5. 执行方法

pro.properties文件代码

className=com.tiger.domain.Student
methodName=sleep
package com.tiger.reflect;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * power by tigerchen
 */
public class reflectTest {
    public static void main(String[] args) throws Exception {
        //1.加载配置文件
        //1.1创建Properties对象
        Properties properties = new Properties();
        //1.2加载配置文件，转换为一个集合
        ClassLoader classLoader = reflectTest.class.getClassLoader();
        InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");
        properties.load(resourceAsStream);
        //1.2.1获取class目录下的配置文件
        String classname = properties.getProperty("className");
        String methodName = properties.getProperty("methodName");
        //3.加载该类进内存
        Class<?> aClass = Class.forName(classname);
        //4.创建对象
        Object o = aClass.newInstance();
        //System.out.println(o);
        //5.获取方法对象
        Method method = aClass.getMethod(methodName);
        //6.执行方法
        method.invoke(o);
    }
}

使用反射可以越过泛型检查

package com.tiger.reflect;

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * power by tigerchen
 */
public class reflectDemo05 {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(123);
        Class<?> aClass = list.getClass();
        Method add = aClass.getMethod("add", Object.class);
        add.invoke(list,"aaaa");
        System.out.println(list);
    }
}

通过反射创建一个万能set方法

public class propertyy {
        public  void setProperty(Object obj, String PropertyName, Object value) throws Exception {
            Class<?> aClass = obj.getClass();
            Field declaredField = aClass.getDeclaredField(String.valueOf(PropertyName));
            declaredField.setAccessible(true);
            declaredField.set(obj, value);
           
        }
}

new.properties

ClassName=com.tiger.domain.Person
PropertyName=age
Value=13

test代码

package com.tiger.reflect;

import com.tiger.reflectUntil.propertyy;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

/**
 * power by tigerchen
 */
public class refectDemo6 {
    public static  void main(String[] args) throws Exception {
        ClassLoader classLoader = refectDemo6.class.getClassLoader();
        InputStream resourceAsStream = classLoader.getResourceAsStream("new.properties");
        Class<Properties> propertiesClass = Properties.class;
        Properties properties = propertiesClass.newInstance();
        properties.load(resourceAsStream);
        String className = properties.getProperty("ClassName");
        String propertyName = properties.getProperty("PropertyName");
        int value = Integer.parseInt(properties.getProperty("Value"));
        Class<?> aClass1 = Class.forName(className);
        Object o1 = aClass1.newInstance();
        Class<propertyy> propertyClass = propertyy.class;
        propertyy propertyyy = propertyClass.newInstance();
        Method setProperty = propertyClass.getDeclaredMethod("setProperty",Object.class,String.class,Object.class);
        setProperty.invoke(propertyyy,o1,propertyName,value);
        Method getAge = aClass1.getMethod("getAge");
        Object invoke = getAge.invoke(o1);
        System.out.println(invoke);
        /*Person person = new Person();
        property property = new property();
        property.setProperty(person,"age",12);
        System.out.println(person.getAge());
         */
    }
}

 

Aaron_Kitty
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 反射
12-22
这种动态获取信息以及动态调用对象方法的功能成为java反射机制。 2. java 文件和 .class 文件的关系 java 文件 java文件中包含代码的所有内容，类，接口，成员变量，成员方法.... .class 字节码文件 .class 是由 ...
Java基础之—反射（非常重要）
热门推荐
sinat_38259539的博客
05-13 72万+
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 一、反射的概述 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 要想解剖一个类,必须先要获取到该类的
Java反射详解
最新发布
Welisit的博客
03-07 1122
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可 以通过这个对象看到类的结构。。
反射机制的运用实例
qq_53983985的博客
02-22 221
反射机制的运用实例： 实例一：使用反射机制绕过类型检查（泛型） //创建集合对象，指定元素类型 ArrayList<String> al = new ArrayList<String>(); al.add("hello"); //获取Class类对象 Class<? extends ArrayList
JAVA
沉心听雨
03-25 507
http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html反射机制详解 java反射详解 本篇文章依旧采用小例子来说明，因为我始终觉的，案例驱动是最好的，要不然只看理论的话，看了也不懂，不过建议大家在看完文章之后，在回过头去看看理论，会有更好的理解。 下面开始正文。 【案例1】通过一个对象获得完整的包名和类名
Java反射案例
01-09
Java反射案例，可以参考： Java反射机制 - 相关API：https://blog.csdn.net/niuba123456/article/details/85951088
Java 反射调用设置值
08-01
Java 反射调用设置值
深入理解Java反射
09-01
在理解反射原理之前先要搞清类型信息。接下来通过本文给大家介绍java反射的深入理解，非常不错，具有参考借鉴价值，感兴趣的朋友一起看下吧
java反射简单实例
09-03
主要介绍了java反射机制,以一个简单实例形式分析了Java反射的原理与实现技巧,需要的朋友可以参考下
Java反射机制
huaseven的专栏
10-19 92
一、什么是反射机制 简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字， 那么就可以通过反射机制来获得类的所有信息。 二、哪里用到反射机制 有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码， Class.forName("com.mysql.jdbc....
反射实例
weixin_43956958的博客
11-22 272
1.利用反射实现通用扩展数组长度的方法。 import java.lang.reflect.*; public class Answer_1606 { public static void main(String[] args) { Test test = new Test(); test.print(); test.is = (int[]) addArrayLength(...
反射 简单实例
codelmh的博客
11-24 601
一、案例：支付功能---> 微信、支付宝、云闪付等等 提供一个支付接口 package com.lmh; /**提供支付接口 * @author codelmh * @data 2021/11/24 */ public interface Payment { void payOnline(); } 微信支付实现 支付接口 package com.lmh; /** 微信实现支付接口 * @author codelmh * @data 2021/11/24.
java反射 private
09-22
Java反射是一种强大的Java特性，它允许我们在运行时动态地获取和操作类的信息。通过Java反射，我们可以实现对类中的public方法和private方法的调用。在给定的代码示例中，我们可以看到如何使用Java反射来调用类A中的private方法。 首先，我们使用Class.forName()方法获取类A的Class对象。接下来，我们使用Class.getDeclaredMethod()方法获取类A中名为"Proprint"的私有方法的Method对象。然后，我们使用Method.setAccessible(true)方法将私有方法设置为可访问。最后，我们使用Method.invoke()方法来调用私有方法，并传入一个类A的实例作为参数。 在这个例子中，我们成功地通过Java反射调用了类A中的private方法"Proprint"。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值