Java拾遗1：Java反射机制

最新推荐文章于 2024-07-16 16:14:54 发布
最新推荐文章于 2024-07-16 16:14:54 发布
阅读量337 收藏
点赞数
分类专栏： Java拾遗 文章标签： java 面向对象 反射机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Raymond120/article/details/61937892
版权

一.Class类的使用

  • 在面向对象的世界里，万事万物皆对象
    • 注意：普通的数据类型，int a=5不是对象；static类的东西也不是对象，它属于类
    • 类是对象，类是java.lang.Class类的实例对象，我们称其为该类的类类型。

  • 这个对象如何表示？

    • 三种表示方式

      • Class c1 = Foo.class;//Foo是个类
      • Class c2 = foo.getClass();//foo是Foo类的对象
      • Class c3 = Class.forName("类的全称");

    • 可以通过类类型来创建该类的对象

      • Foo foo = (Foo)c1.newInstance();

  • 示例如下：

package com.imooc.reflect;

public class ClassDemo1 {

    public static void main(String[] args) {
        //Foo的实例对象如何表示
        Foo foo1 = new Foo();

        //Foo这个类 也是一个实例对象，是Class类的实例对象，如何表示？
        //任何一个类都是Class类的实例对象，这个实例对象有3种表示方式

        //第一种：任何一个类都有一个隐含的静态成员变量class
        Class c1 = Foo.class;

        //第二种：已知该类的对象，通过getClass方法
        Class c2 = foo1.getClass();

        //官网c1/c2表示了Foo类的类类型（class type:Foo本身是一个类，也是Class的对象)
        //Foo类的对象是foo1，Foo类的类类型是c1和c2,一个类只可能是Class类的一个对象
        System.out.println(c1 == c2);

        //第三种：
        Class c3 = null;
        try {
            c3 = Class.forName("com.imooc.reflect.Foo");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println(c2 == c3);

        //我们完全可以通过类的类类型创建该类的对象
        try {
            Foo foo = (Foo)c1.newInstance();//需要有无参数的构造方法
            foo.print();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }
}

class Foo{

    void print(){
        System.out.println("foo");
    }
}

二.Java动态加载类

  • Class c = Class.forName("类的全称"）
    • 不仅表示了类的类类型，还代表了动态加载类
    • 编译时刻加载类是静态加载类，运行时刻加载类是动态加载类
      • new 创建对象 是静态加载类，在编译时刻就需要加载所有的可能使用到的类。
      • 通过动态加载类可以解决在静态加载时类不存在的问题，它是在运行时刻加载类
      • 动态加载类可以用于功能的扩展

  • 示例：

    //Version 1.0
//Office.java
class Office{
public static void main(String[] args){
    if("Word".equals(args[0]){
        Word w = new Word();
        w.start();
    }
    if("Excel".equals(args[0]){
        Excel e = new Word();
        e.start();
    }
}
}

//这个版本中，Word,Excel类都没有存在，因此编译出错
//new 创建对象 是静态加载类，在编译时刻就需要加载所有的可能使用到的类。
//通过动态加载类可以解决这个问题

//version2.0
//OfficeBetter.java
class OfficeBetter{
public static void main(String[] args){
    //new 创建对象 是静态加载类，在编译时刻就需要加载所有的可能使用到的类。
    //通过动态加载类可以解决这个问题,功能性的类最好用动态加载，而不是静态加载
    try{
        //动态加载类，在运行时刻加载
        Class c = Class.forName("args[0]");
        //通过类类型，创建该类对象
        OfficeAble oa = (OfficeAble)c.newInstance();
        oa.start();
    }catch(Exception e){
        e.printStackTrace();
    }
}
}

interface OfficeAble{
    public void start();
}

class Word implements OfficeAble{
public void start(){
    System.out.println("word...start");
}
}

...
//后续我们如果需要其他加载其他功能类，例如Excel，PPT,那么我们不用改OfficeBetter.java，直接添加类就可以了

三.Java获取成员函数，成员变量及构造函数信息

1.基本的数据类型，void关键字都存在类类型

  • 示例如下
package com.imooc.reflect;

public class ClassDemo2 {

    public static void main(String[] args) {
        Class c1 = int.class;//int 的类类型
        Class c2 = String.class;//String类的类类型
        Class c3 = double.class;
        Class c4 = Double.class;
        Class c5 = void.class;

        System.out.println(c1.getName());//获得类名
        System.out.println(c2.getName());
        System.out.println(c2.getSimpleName());//不含包名的类的名称
        System.out.println(c5.getName());
    }

}

//运行结果：
  int
  java.lang.String
  String
  void

2.Class类的基本API操作：获取成员函数，成员变量及构造函数信息

  • 获取类的信息，都是从获的类的类类型开始的
    • Class c = obj.getClass();//获取类的类类型
    • String className = c.getName();//获取类名
  • 获取类的成员函数
    • getMethods()方法获取的是所有的public的函数，包括父类继承而来的
      • Method[] ms = c.getMethods();
    • getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
      • Method[] ms = c.getDeclaredMethods()
  • 获取类的成员变量
    • getFields()方法获取的是所有的public的成员变量的信息
      • Field[] fs = c.getFields();
    • getDeclaredFields()获取的是该类自己声明的成员变量的信息
      • Field[] fs = c.getDeclaredFields();
  • 获取类的构造函数
    • getConstructor()方法获取的是所有的public的构造函数的信息
      • Constructor[] cs = c.getConstructors();
    • getDeclaredConstructor()获取的是该类自己声明的所有构造函数
      • Constructor[] cs = c.getDeclaredConstructors();
  • 示例如下：
package com.imooc.reflect;

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

public class ClassUtil {
    /**
     * 打印类的信息，包括类的成员函数，成员变量及构造函数
     * obj 该对象所属类的信息
     * 要打印类的信息，都是从获得类的类类型开始的
     */

    /*
     * 打印类的成员函数
     */
    public static void printMethodMessage(Object obj){
        //要获取类的类类型
        Class c = obj.getClass();//传递的是哪个子类的对象， c就是该子类的类类型,例如，int.class
        //获取类的名称
        System.out.println("类的名称是："+c.getName());

        /*
         * Method类，方法对象
         * 一个成员方法就是一个Method对象
         * getMethods()方法获取的是所有的public的函数，包括父类继承而来的
         * getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
         */

        Method[] ms = c.getMethods();//c.getDeclaredMethods()
        for(int i = 0; i < ms.length; i++){
            //得到方法返回值类型的类类型，如int.class
            Class returnType = ms[i].getReturnType();
            System.out.print(returnType.getName()+" ");
            //得到方法的名称
            System.out.print(ms[i].getName()+"(");
            //获取参数类型：得到参数列表的类型的类类型
            Class[] paramType = ms[i].getParameterTypes();
            for(Class class1 : paramType){
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }
    }

    /*
     * 打印类的成员变量
     */
    public static void printFieldMessage(Object obj) {
        //获取类的类类型
        Class c = obj.getClass();
        /*
        * 成员变量也是对象，是java.lang.reflect.Field类的对象
        * Field类封装了关于成员变量的操作
        * getFields()方法获取的是所有的public的成员变量的信息
        * getDeclaredFields()获取的是该类自己声明的成员变量的信息
        */
        //Field[] fs = c.getFields();
        Field[] fs = c.getDeclaredFields();
        for (Field field : fs) {
            //得到成员变量的类型的类类型
            Class fieldType = field.getType();
            //得到成员变量的类型名
            String typeName = fieldType.getName();
            //得到成员变量的名称
            String fieldName = field.getName();
            System.out.println(typeName+" "+fieldName);
            }
    }

    /*
     * 打印类的构造函数
     */
    public static void printConMessage(Object obj){
        Class c = obj.getClass();
        /*
        * 构造函数也是对象，是java.lang.Constructor类的对象
        * Field类封装了关于成员变量的操作
        * getConstructor()方法获取的是所有的public的构造函数的信息
        * getDeclaredConstructor()获取的是该类自己声明的所有构造函数
        */
        Constructor[] cs = c.getDeclaredConstructors();
        for (Constructor constructor : cs) {
            //获取的是构造函数的名称
            System.out.print(constructor.getName()+"(");
            //获取构造函数的参数列表：得到参数列表的类类型
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class class1 : paramTypes) {
                System.out.print(class1.getName()+",");
            }
            System.out.println(")");
        }
    }
}

package com.imooc.reflect;

public class ClassDemo3 {

    public static void main(String[] args) {
        String s = "hello";
        ClassUtil.printMethodMessage(s);

        System.out.println("===============");

        Integer n = 1;
        ClassUtil.printFieldMessage(n);

        System.out.println("===============");

        ClassUtil.printFieldMessage("world");

        System.out.println("===============");

        ClassUtil.printMethodMessage(new Integer(1));

        System.out.println("===============");

        ClassUtil.printConMessage(s);

        System.out.println("===============");

        ClassUtil.printConMessage(n);
    }
}

四.Java反射的基本操作:方法的反射

  • 如何获取某个方法？
    • 方法的名称和方法的参数列表唯一决定某个方法
  • 方法反射的操作
    • Class c = obj.getClass();//获取类的类类型
    • Method m = c.getMethod(方法名，参数列表)
    • method.invoke(对象，参数列表)
      • A a1 = new A();
      • Class c = a1.getClass();
      • Method m = c.getMethod("print", int.class, int.class);
      • Object o = m.invoke(a1, 10, 20);

示例：

package com.imooc.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class MethodDemo1 {

    public static void main(String[] args) {
        /*
         * 要获取print(int, int)方法
         * 1.要获取方法就是获取类的信息，获取类的信息，首先要获取类的类类型
         */
        A a1 = new A();
        Class c = a1.getClass();
        /*
         * 2.获取方法名称和参数列表
         * getMethod()获取的是public的方法
         * getDeclaredMethod()获取的是自己声明的方法
         */
        try {
            //Method m = c.getMethod("print", new Class[]{int.class, int.class});
            Method m = c.getMethod("print", int.class, int.class);

            /*
             * 方法的反射操作
             * a1.print(10,20);方法的反射操作是用m对象来进行方法调用，和a1.print调用的效果相同
             * 方法如果没有返回值，返回null；如果有返回值，返回具体的返回值
             */
            //m.invoke(a1, new Object[]{10,20});
            Object o = m.invoke(a1, 10, 20);

            System.out.println("===============");

            //获取方法print(String,String)
            Method m1 = c.getMethod("print", String.class, String.class);
            //用方法进行反射操作
            o = m1.invoke(a1, "hello","WORLD");

            System.out.println("===============");

            //Method m2 = c.getMethod("print",new Class[]{});
            //m2.invoke(a1,new Object[]{});
            Method m2 = c.getMethod("print");
            m2.invoke(a1);

        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }

}

class A {
    public void print(){
        System.out.println("helloworld");
    }

    public void print(int a, int b){
        System.out.println(a+b);
    }

    public void print(String a, String b){
        System.out.println(a.toUpperCase()+","+b.toLowerCase());
    }
}

五.通过反射了解集合泛型的本质

  • 反射的操作都是编译之后的操作
  • Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
  • 编译结束，则泛型无效，因此，如果绕过编译，泛型就无效了
package com.imooc.reflect;

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

public class MethodDemo2 {

    public static void main(String[] args) {
        ArrayList list = new ArrayList();//可以放任何类型

        ArrayList<String> list1 = new ArrayList<String>();//只能放String类型

        list1.add("hello");
        //list1.add(20);错误的
        Class c1 = list.getClass();
        Class c2 = list1.getClass();
        System.out.println(c1 == c2);
        //总结：反射的操作都是编译之后的操作，也就是生成.class之后的操作

        /*
         * c1 == c2结果返回true,说明编译之后集合的泛型是去泛型化的
         * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，
         * 编译结束，则泛型无效，因此，如果绕过编译，泛型就无效了
         * 验证：我们可以通过反射操作，绕过编译
         */

        try {
            Method m = c2.getMethod("add", Object.class);
            m.invoke(list1, 20);//绕过编译操作就绕过泛型
            System.out.println(list1.size());
            System.out.println(list1);
            /*for (String string : list1) {
                System.out.println(string);
            }*///编译时执行，因此现在不能再这样遍历了

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

参考文献

  1. Cendar, 反射——JAVA高级开发必须懂的

水平有限，错误和不妥之处请指出，谢谢~

GKD
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java拾遗：006 - Java反射与内省
weixin_33767813的博客
08-04 145
2019独角兽企业重金招聘Python工程师标准>>> ...
黑马程序员——java拾遗之反射机制
bbdeyouxang的专栏
09-25 377
“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”，Java不是动态语言。但是JAVA有着一个非常突出的动态相关机制：反射机制。指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。
Java中的反射机制
yhao的博客
06-03 8694
在我的上篇文章模拟JDK动态代理实现中涉及到了反射机制，学无止境，在此系统的学习一下Java中的反射机制。首先给出Java反射机制的定义： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 从以上的描述中可以看出Java中的动态特性，那么
Java知识拾遗：三大框架的技术起源
05-03
Java知识拾遗：三大框架的技术起源 本篇文章主要讲述了Java开发中三大框架的技术起源，即Struts、Hibernate和Spring框架。这些框架是我们Java开发中的常用的框架，它们分别针对不同的应用场景给出最合适的解决方案...
11.java基础拾遗--匿名内部类语法详解.mp4
04-30
11.java基础拾遗--匿名内部类语法详解.mp4
[Java拾遗]Java对象大小探究
03-27
NULL 博文链接：https://langyu.iteye.com/blog/1167581
09.java基础拾遗--类的加载和对象的构造过程.mp4
04-29
09.java基础拾遗--类的加载和对象的构造过程.mp4
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 591
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
基于Java技术的校园台球厅人员与设备管理系统
heye0910032的博客
07-12 565
本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。该系统利用MySQL数据库进行数据存储，实现了包括首页、个人中心、用户管理、会员账号管理、会员充值管理、球桌信息管理、会员预约管理、普通预约管理、留言反馈和系统管理等多功能集成。系统设计考虑了用户友好性和操作便捷性，旨在提高校园台球厅人员与设备管理的效率和质量。本文介绍了一个基于Java技术和SpringBoot框架开发的校园台球厅人员与设备管理系统。
Java 中有哪几种基本数据类型？请分别列出它们并简述每种数据类型的特点及其在内存中的占用空间？
liangzai215的专栏
07-15 319
在Java的世界里，数据是构建应用程序的基石。为了高效地处理这些数据，Java设计了一系列基础数据类型，它们直接映射到计算机硬件上，因此在性能和内存使用上更为高效。我们常说的Java八大基本数据类型，涵盖了整数、浮点数、字符和布尔值，下面我将一一介绍它们的特点以及在内存中的占用空间，并通过简单的代码实例来加深理解。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 645
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
maven项目容器化运行之1-基于1Panel软件将docker镜像构建能力分享给局域网
qq_37372909的博客
07-15 416
docker核心功能包括镜像的构建和容器的运行，它可以开放端口将镜像构建的能力暴露。docker daeson就是docker的守护进程，开放能力是通过指定docker守护进程监听端口来实现的。后面开发人员就可以通过maven中docker插件来远程调用docker镜像构建能力了。
秋招Java后端开发冲刺——MyBatisPlus总结
qq_50604294的博客
07-13 745
本文对MyBatisPlus进行了介绍，并对其特点、基本使用和扩展功能进行了总结概括。
uboot的功能
weixin_43732386的博客
07-13 53
uboot=裸机程序，uboot的核心功能是启动内核。
Java实验2
最新发布
qq_64727229的博客
07-16 337
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
Java：ThreadPoolExecutor线程池知识体系
彭世瑜的博客
07-15 335
ThreadPoolExecutor的构造方法。固定大小线程数的线程池。
【利用Selenium+autoIt实现文件上传】
凌飞安
07-16 236
当文件上传功能不能简单修改value属性的时候，你一定要看一下我这片文章。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值