开发者社区> (小唐同学)> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

Java反射的前世今生

简介: Java反射的前世今生
+关注继续查看


目录

一、反射是什么?

二、获取Class类对象的方式

1. Class.forName(String name)

2.类名.Class

3.对象.getClass()

4.综合代码

(1)实用类Person

(2)测试类  ReflectDemo1

5.Class类对象的获取-总结

三、Class对象的功能

1.获取成员变量

(1) Field[] getfields():

(2)Field getField(String name);

 (3)Field[] getDeclaredFields()

(4)Field getDeclaredField(String name)

(5)获取成员变量代码总结

2.获取构造方法

(1)(带参)getConstructor()

(2)无参构造方法----1

(3)无参构造方法----2

(4)获取构造方法代码总结

3.获取成员方法

(1)无参成员方法

(2)有参成员方法

(3)获取所有public修饰的方法

(4)获取方法名-获取类名

(5)获取成员方法代码总结

四、反射案例

1.加载配置文件

2.获取配置文件中定义的数据

3.反射  加载该类进入内存

4.创建对象

5.获取方法对象

6.执行方法

7.代码总结


一、反射是什么?

   框架:是半成品软件,可以在框架的基础上进行软件开发,简化编码

   反射:是框架设计的灵魂,将类的各个组成部分封装成其他对象,这就是反射机制

        好处:1.可以在程序运行过程中,操作这些对象

                    2.可以解耦,提高程序的可扩展性。

                    **(耦合性(Coupling),也叫耦合度,是对模块间关联程度的度量。模块间的耦合度是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。模块间联系越多,其耦合性越强,同时表明其独立性越差( 降低耦合性,可以提高其独立性)。)

          Java代码在计算机中经历的三个阶段

image    源代码阶段                                                      Class类对象阶段                                 运行时阶段

(还是在硬盘上没有进内存)                    (把个部分抽取出来封装成对象)

二、获取Class类对象的方式

1. Class.forName(String name)

用Class.forName(“全类名”);得到Class类对象

//1.多用于配置文件

Class<?> cls1 = Class.forName("cn.domain.Person");

2.类名.Class

Class cls=类名.Class;

//2.参数的传递

Class<Person> cls2 = Person.class;

3.对象.getClass()

直接上代码把,更直观点

//3.多用于对象的获取字节码的方式

 Person p=new Person();
 Class<? extends Person> cls3 = p.getClass();

4.综合代码

(1)实用类Person

package cn.domain;
 
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;
    }
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
}

(2)测试类  ReflectDemo1

package cn.reflect;
import cn.domain.Person;
 
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
       //1.多用于配置文件
        Class<?> cls1 = Class.forName("cn.domain.Person");
        System.out.println(cls1);
        //2.参数的传递
        Class<Person> cls2 = Person.class;
        System.out.println(cls2);
        //多用于对象的获取字节码的方式
        Person p=new Person();
        Class<? extends Person> cls3 = p.getClass();
        System.out.println(cls3);
        //三种方式获得的class对象   对象是同一个对象
    }
}

5.Class类对象的获取-总结

同一个字节码文件( .class)在一次程序运行的过程中,只会被加载一次(通过类加载器,加载入内存),无论通过那种方式获取,获取的类对象是同一个。

三、Class对象的功能

1.获取成员变量

(1) Field[] getfields():

获取类中所有public修饰的成员变量

 //1.获取PersonClass 对象
         Class<Person> personClass = Person.class;
 //1.获取成员变量 Field[] getFields
         Field[] fields = personClass.getFields();
 for(Field field:fields)
 {
     System.out.println(field);
 //什么也得不到  只会获取公共的成员变量(public)   没办法获取私有的
 }

(2)Field getField(String name);

获取指定的成员变量(获取对象后  get(),set() 方法)

    Field a=personClass.getField("a");
     Person p=new Person();
 //     Object o = a.get(p);
 
 Object o = a.get(p);
         System.out.println(o);

获取后可以设置成员变量的值

   Field a=personClass.getField("a");
    Person p=new Person();
 //     Object o = a.get(p);
         a.set(p,"100");
         System.out.println(p);
 Object o = a.get(p);
         System.out.println(o);

运行结果:

image

(3)Field[] getDeclaredFields()

获取类中所有的成员变量(不管修饰符)

   Field[] declaredFields = personClass.getDeclaredFields();
 for (Field de:declaredFields)
        {
            System.out.println(de);
        }

(4)Field getDeclaredField(String name)

获取指定的成员变量

 Field d = personClass.getDeclaredField("d");
 Object o1 = d.get(p);
         System.out.println(o1);

可以获取 我们可以想到也可以设置值 但是  又知道私有的是不能在类外被访问到其实在反射中是不存在私有公有的(需要暴力反射,忽略访问权限修饰符的安全检查)

这样执行会报错

image

这就是访问私有成员的结果,所以需要暴力反射

在获取Field对象后加了暴力反射代码赋值为true

 Field d = personClass.getDeclaredField("d");
         d.setAccessible(true);
 Object o1 = d.get(p);
         System.out.println(o1);

(5)获取成员变量代码总结

package cn.reflect;
 
import cn.domain.Person;
 
import java.lang.reflect.Field;
 
public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        //1.获取PersonClass 对象
        Class<Person> personClass = Person.class;
 
 
 
        //1.获取成员变量 Field[] getFields
        Field[] fields = personClass.getFields();
for(Field field:fields)
{
    System.out.println(field);
    //什么也得不到  只会获取公共的成员变量(public)   没办法获取私有的
}
        System.out.println("----------------------");
        Field a=personClass.getField("a");
    Person p=new Person();
   //     Object o = a.get(p);
        a.set(p,"100");
        System.out.println(p);
        Object o = a.get(p);
        System.out.println(o);
 
        System.out.println("---------2---------");
        Field[] declaredFields = personClass.getDeclaredFields();
       for (Field de:declaredFields)
       {
           System.out.println(de);
       }
        System.out.println("------------3------");
 
        Field d = personClass.getDeclaredField("d");
        d.setAccessible(true);
        Object o1 = d.get(p);
        System.out.println(o1);
 
 
    }
 
 
 
 
 
}

2.获取构造方法

(1)(带参)getConstructor()

getConstructor() 是获取构造器的方法    返回的是构造器

构造方法是创建对象的

Constructor对象是   得到的是构造方法(构造器)

  Class<Person> personClass = Person.class;
     //获取类的构造方法
        //返回一个构造器           参数为类
        Constructor<Person> constructor = personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);
       //Constructor对象是   得到的是构造方法
        //构造方法是创建对象的
        Person person = constructor.newInstance("zhangsan",19);
        System.out.println(person);

(2)无参构造方法----1

此方法先得到构造器对象

在通过构造器对象得到构造方法

Constructor<Person> constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        Person person1 = constructor1.newInstance();
        System.out.println(person1);

(3)无参构造方法----2

此方法通过Class对象直接调用方法

 步骤得到简化   但是现在好像不建议使用

 Person person2 = personClass.newInstance()         System.out.println(person2);

(4)获取构造方法代码总结

package cn.reflect;
 
import cn.domain.Person;
 
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
 
public class ReflectDemo3 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<Person> personClass = Person.class;
     //获取类的构造方法
        //返回一个构造器           参数为类
        Constructor<Person> constructor = personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);
       //Constructor对象是   得到的是构造方法
        //构造方法是创建对象的
        Person person = constructor.newInstance("zhangsan",19);
        System.out.println(person);
        System.out.println("---------------------");
            //空参构造
        Constructor<Person> constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        Person person1 = constructor1.newInstance();
        System.out.println(person1);
        System.out.println("-----------------------");
        Person person2 = personClass.newInstance();
        System.out.println(person2);
        System.out.println("------------------------");
        Constructor<Person> personConstructor = personClass.getDeclaredConstructor(String.class, int.class);
        Person nb = personConstructor.newInstance("nb", 19);
        System.out.println(nb);
 
 
    }
}
    //

3.获取成员方法

(1)无参成员方法

先创建  Method  对象

还需要创建 Object   类对象  后边调用invoke()方法需要用到

 Class<Person> personClass = Person.class;
//Method  对象  是方法对象       无参不需要传参
        Method eat = personClass.getMethod("eat");
        //进行完这个需要创建个对象   后面方法需要调用
        Person p=new Person();
        //invoke(p)  若有参函数 则需要传入p   和他的参数
        eat.invoke(p);

(2)有参成员方法

在创建    Method 方法时  需要传入参数的类型

调用invoke时   传参需要先传入Object   类对象    再传入 参数值

   Person p=new Person();
 Method method = personClass.getMethod("eat", String.class);
         method.invoke(p,"food");

(3)获取所有public修饰的方法

这个获取的不光本类  还有它父类的

如果他不继承任何类   则只继承了  Object   类

获取时会获取Object   类的public修饰的成员方法和本类public修饰的成员方法

  Method[] methods = personClass.getMethods();
        for (Method method1:methods)
        {
            System.out.println(method1);
         //   method1.setAccessible(true);
        }

(4)获取方法名-获取类名

   Method[] methods = personClass.getMethods();
        for (Method method1:methods)
        {
            System.out.println(method1);
         //   method1.setAccessible(true);  //获取方法名
                    String name = method1.getName();
                    System.out.println(name);
        }
 String name = personClass.getName();
         System.out.println(name);

(5)获取成员方法代码总结

package cn.reflect;
 
import cn.domain.Person;
 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class ReflectDemo4 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException {
 
        Class<Person> personClass = Person.class;
//Method  对象  是方法对象       无参不需要传参
        Method eat = personClass.getMethod("eat");
        //进行完这个需要创建个对象   后面方法需要调用
        Person p=new Person();
        //invoke(p)  若有参函数 则需要传入p   和他的参数
        eat.invoke(p);
         //有参成员方法
        Method method = personClass.getMethod("eat", String.class);
        method.invoke(p,"food");
        System.out.println("---------------");
                //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method1:methods)
        {
            System.out.println(method1);
         //   method1.setAccessible(true);  //获取方法名
                    String name = method1.getName();
                    System.out.println(name);
        }
        System.out.println("-----------");
 
 
    }
}

四、反射案例

需求:写一个“框架”,可以帮我们创建任意类的对象,并且执行其中任意方法

         实现需求:

1.配置文件

2.反射

       步骤:

1.将需要创建的对象的全类名和需要执行的方法定义在配置文件中

2.在程序中加载读取配置文件

3.使用反射技术加载类文件进内存

4.创建对象

5.执行方法

1.加载配置文件

  1.1 创建 Properties 对象

  1.2加载配置文件  ,转换为一个集合

    1.2.1 获取class目录下的配置文件

//1.加载配置文件
//1.1 创建 Properties 对象
    Properties pro=new Properties();
//1.2加载配置文件  ,转换为一个集合
    //1.2.1 获取class目录下的配置文件
 
    ClassLoader classLoader = Reflecttest.class.getClassLoader();//获取该字节码文件的类加载器  是由类加载器把字节码文件加载入内存的
    InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");//获取资源对应的资源流
 
 
    pro.load(resourceAsStream);

2.获取配置文件中定义的数据

 String className = pro.getProperty("className");
 String methodName = pro.getProperty("methodName");

3.反射  加载该类进入内存

Class<?> aClass = Class.forName(className);

4.创建对象

Object o = aClass.newInstance();

5.获取方法对象

Method method = aClass.getMethod(methodName);

6.执行方法

method.invoke(o);

7.代码总结

package cn.reflect;
 
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;
 
/*
*框架类
* */
public class Reflecttest {
//可以创建任意类对象   可以执行任一方法
public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
//1.加载配置文件
//1.1 创建 Properties 对象
    Properties pro=new Properties();
//1.2加载配置文件  ,转换为一个集合
    //1.2.1 获取class目录下的配置文件
 
    ClassLoader classLoader = Reflecttest.class.getClassLoader();//获取该字节码文件的类加载器  是由类加载器把字节码文件加载入内存的
    InputStream resourceAsStream = classLoader.getResourceAsStream("pro.properties");//获取资源对应的资源流
 
 
    pro.load(resourceAsStream);
//2.获取配置文件中定义的数据
    String className = pro.getProperty("className");
    String methodName = pro.getProperty("methodName");
    //3.反射  加载该类进入内存
    Class<?> aClass = Class.forName(className);
    //4.创建对象
    Object o = aClass.newInstance();
    //5.获取方法对象
    Method method = aClass.getMethod(methodName);
    //6.执行方法
    method.invoke(o);
 
 
}
 
 
}


版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
【Java基础】RTTI与反射之Java
很多时候我们的程序可能需要在运行时识别对象和类的信息,比如多态就是基于运行时环境进行动态判断实际引用的对象。在运行时识别对象和类的信息主要有两种方式:1.RTTI,具体是Class对象,它假定我们在编译时已经知道了所有类型。2.反射机制,运行我们在运行时发现和使用类的信息。
39 0
Java基础——反射
Java基础——反射
30 0
Java基础之反射整理
什么是反射? Java反射就是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;并且能改变它的属性。而这也是Java被视为动态(或准动态,为啥要说是准动态,因为一般而言的动态语言定义是程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言。
3308 0
Java基础13:反射详解
版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/a724888/article/details/80160662 这位大侠,这是我的公众号:程序员江湖。
1332 0
Java基础巩固——反射
什么是反射    反射机制就是指程序运行时能够获取自身的信息。在Java中,只要给出类的名字,就可以通过反射机制来获取类的信息 哪里用的到反射机制    在jdbc中就是使用的反射来实例化对象,比如:Class.forName("com.mysql.jdbc.Driver.class").newInstance();    框架都用到反射机制,spring,hibernate、struts都是用反射机制实现的。
981 0
Java基础-反射
1、反射的机制是什么? 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
726 0
java基础之反射
Contents java基础巩固笔记(1)-反射 反射 反射基本使用 数组的反射 配置文件加载 内省(Instropector) &amp; JavaBean 反射 反射:将类的属性和方法映射成相应的类。 反射基本使用 获取Class类的三种方法: 类名.class 对象名.getClass() Class.forName("要加载的类
973 0
Java网络编程Demo,使用TCP 实现简单群聊功能GroupchatSimple,多个客户端输入消息,显示在服务端的控制台
Java网络编程Demo,使用TCP 实现简单群聊功能GroupchatSimple,多个客户端输入消息,显示在服务端的控制台
30 0
Java网络编程Demo,使用TCP 实现简单群聊功能Groupchat,创建一个服务端,使多个客户端都能收到消息
Java网络编程Demo,使用TCP 实现简单群聊功能Groupchat,创建一个服务端,使多个客户端都能收到消息
40 0
+关注
(小唐同学)
保持学习,持续前进
55
文章
1
问答
文章排行榜
最热
最新
相关电子书
更多
低代码开发师(初级)实战教程
立即下载
阿里巴巴DevOps 最佳实践手册
立即下载
冬季实战营第三期:MySQL数据库进阶实战
立即下载