第16章_反射

最新推荐文章于 2024-11-03 11:50:36 发布
最新推荐文章于 2024-11-03 11:50:36 发布
阅读量75 收藏
点赞数
分类专栏： JavaSE 文章标签： 面试 职场和发展 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/beans_blog/article/details/128622808
版权

一、通过案例体会反射的好处

案例：美团外卖 --->付款 ---》要么用微信支付 要么用支付宝支付 

package com.zhaoss.test01;
//接口的制定方：美团外卖
public interface Mtwm {
    //在线支付功能：
    void payOnline();
}
public class WeChat implements Mtwm{
    @Override
    public void payOnline() {
        //具体实现微信支付的功能：
        System.out.println("我已经点了外卖，正在使用微信支付");
    }
}
public class AliPay implements Mtwm {
    @Override
    public void payOnline() {
        //具体的支付宝支付：
        System.out.println("我已经点了外卖，我正在使用支付宝进行支付");
    }
}
public class BankCard implements Mtwm{
    @Override
    public void payOnline() {
        System.out.println("我已经定了外卖，我正在用招商银行信用卡支付");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        //定义一个字符串，用来模拟前台的支付方式：
        String str = "微信";
        if("微信".equals(str)){//str.equals("微信")---？避免空指针异常
            //微信支付：
            //new WeChat().payOnline();
            pay(new WeChat());
        }
        if("支付宝".equals(str)){
            //支付宝支付：
            //new AliPay().payOnline();
            pay(new AliPay());
        }
        if("招商银行".equals(str)){
            pay(new BankCard());
        }
    }
    //微信支付
    public static void pay(WeChat wc){
        wc.payOnline();
    }
    //支付宝支付
    public static void pay(AliPay ap){
        ap.payOnline();
    }
    //招商银行支付
    public static void pay(BankCard bc){
        bc.payOnline();
    }
}

为了提高代码的扩展性---》面向对象特性：多态：

public class Test {
    public static void main(String[] args) {
        //定义一个字符串，用来模拟前台的支付方式：
        String str = "微信";
        if("微信".equals(str)){//str.equals("微信")---？避免空指针异常
            //微信支付：
            pay(new WeChat());
        }
        if("支付宝".equals(str)){
            //支付宝支付：
            pay(new AliPay());
        }
        if("招商银行".equals(str)){
            pay(new BankCard());
        }
    }
    //方法形参是接口，具体传入的是接口的实现类的对象---》多态的一种形式
    public static void pay(Mtwm m){
        m.payOnline();
    }

}

多态确实可以提高代码的扩展性，但是：扩展性没有达到最好。

怎么没有达到最好：上面的分支，还是需要手动的删除或者添加。

解决办法：反射机制

利用反射实现上述功能：

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class Demo {
    public static void main(String[] args) throws Exception {
        //定义一个字符串，用来模拟前台的支付方式：
        String str = "com.zhaoss.test01.AliPay";  //字符串：实际上：就是微信类的全限定路径
        //下面的代码就是利用反射：
        Class  cls = Class.forName(str);//cls-->Class类具体的对象--》AliPay字节码信息
        Object o = cls.newInstance();
        Method method = cls.getMethod("payOnline");
        method.invoke(o);
    }
}

二、通过概念再体会反射

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，

都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

在编译后产生字节码文件的时候，类加载器子系统通过二进制字节流，负责从文件系统加载class文件。

在执行程序（java.exe）时候，将字节码文件读入JVM中--->这个过程叫做类的加载。然后在内存中对应创建一个java.lang.Class对象-->这个对象会被放入字节码信息中,这个Class对象,就对应加载那个字节码信息,这个对象将被作为程序访问方法区中的这个类的各种数据的外部接口。

所以：我们可以通过这个对象看到类的结构，这个对象就好像是一面镜子，透过镜子看到类的各种信息，我们形象的称之为反射

这种“看透”class的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。

说明：在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。

如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象。

补充:

动态语膏vs静态语言

1、动态语言

是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以

被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运

行时代码可以根据某些条件改变自身结构。

主要动态语言: Object-C、 C#、JavaScript、 PHP、 Python、 Erlang 。

2、静态语言

与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、

C++。

所以Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动

态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。

Java的动态性让编程的时候更加灵活!

三、Class类的理解

四、提供丰富的类

package com.zhaoss.test02;
//作为一个父类
public class Person {
    //属性
    private int age;
    public String name;
    //方法
    private void eat(){
        System.out.println("Person---eat");
    }
    public void sleep(){
        System.out.println("Person---sleep");
    }
}
package com.zhaoss.test02;
//Student作为子类
public class Student extends Person {
    //属性：
    private int sno;//学号
    double height;//身高
    protected double weight;//体重
    public double score;//成绩
    //方法：
    public String showInfo(){
        return "我是一名三好学生";
    }
    private void work(){
        System.out.println("我以后会找工作--》成为码农  程序员 程序猿  程序媛");
    }
    //构造器
    public Student(){
        System.out.println("空参构造器");
    }
    private Student(int sno){
        this.sno = sno;
    }
    Student(int sno,double weight){
        this.sno = sno;
        this.weight = weight;
    }
}

五、获取字节码信息的四种方式

package com.zhaoss.test02;
public class Test {
    public static void main(String[] args) throws ClassNotFoundException {
        //案例：以Person的字节码信息为案例
        //方式1：通过getClass()方法获取
        Person p = new Person();
        Class c1 = p.getClass();
        System.out.println(c1);
        //方式2：通过内置class属性：
        Class c2 = Person.class;
        System.out.println(c2);
        System.out.println(c1==c2);
        //注意：方式1和方式2  不常用
        //方式3：--》用的最多：调用Class类提供的静态方法forName
        Class c3 = Class.forName("com.zhaoss.test02.Person");
        //方式4：利用类的加载器(了解技能点)
        ClassLoader loader = Test.class.getClassLoader();
        Class c4 = loader.loadClass("com.zhaoss.test02.Person");
    }
}

六、可以作为Class类的实例的种类

Class类的具体的实例：

（1）类：外部类，内部类

（2）接口

（3）注解

（4）数组

（5）基本数据类型

（6）void

验证：

package com.zhaoss.test02;
public class Demo {
    public static void main(String[] args) {
        /*
        Class类的具体的实例：
        （1）类：外部类，内部类
        （2）接口
        （3）注解
        （4）数组
        （5）基本数据类型
        （6）void
         */
        Class c1 = Person.class;
        Class c2 = Comparable.class;
        Class c3 = Override.class;
        int[] arr1 = {1,2,3};
        Class c4 = arr1.getClass();
        int[] arr2 = {5,6,7};
        Class c5 = arr2.getClass();
        System.out.println(c4==c5);//结果：true .同一个维度，同一个元素类型,得到的字节码就是同一个
        
        Class c6 = int.class;
        Class c7 = void.class;
    }
}

七、获取运行时类的完整结构

    • 补充完善上面提供的丰富的类

//作为一个父类
public class Person implements Serializable {
    //属性
    private int age;
    public String name;
    //方法
    private void eat(){
        System.out.println("Person---eat");
    }
    public void sleep(){
        System.out.println("Person---sleep");
    }
}
package com.zhaoss.test03;
//Student作为子类
@MyAnnotation(value="hello")
public class Student extends Person implements MyInterface{
    //属性：
    private int sno;//学号
    double height;//身高
    protected double weight;//体重
    public double score;//成绩
    //方法：
    @MyAnnotation(value="himethod")
    public String showInfo(){
        return "我是一名三好学生";
    }
    public String showInfo(int a,int b){
        return "重载方法====我是一名三好学生";
    }
    private void work(){
        System.out.println("我以后会找工作--》成为码农  程序员 程序猿  程序媛");
    }
    void happy(){
        System.out.println("做人最重要的就是开心每一天");
    }
    protected int getSno(){
        return sno;
    }
    //构造器
    public Student(){
        System.out.println("空参构造器");
    }
    private Student(int sno){
        this.sno = sno;
    }
    Student(int sno,double weight){
        this.sno = sno;
        this.weight = weight;
    }
    protected Student(int sno,double height,double weight){
        this.sno = sno;
    }
    @Override
    @MyAnnotation(value="hellomyMethod")
    public void myMethod() {
        System.out.println("我重写了myMethod方法。。");
    }
    @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", height=" + height +
                ", weight=" + weight +
                ", score=" + score +
                '}';
    }
}

    • 获取构造器和创建对象

package com.zhaoss.test03;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Test01 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取字节码信息：
        Class cls = Student.class;
        //通过字节码信息可以获取构造器：
        //getConstructors只能获取当前运行时类的被public修饰的构造器
        Constructor[] c1 = cls.getConstructors();
        for(Constructor c:c1){
            System.out.println(c);
        }
        System.out.println("-------------------");
        //getDeclaredConstructors:获取运行时类的全部修饰符的构造器
        Constructor[] c2 = cls.getDeclaredConstructors();
        for(Constructor c:c2){
            System.out.println(c);
        }
        System.out.println("-------------------");
        //获取指定的构造器：
        //得到空构造器
        Constructor con1 = cls.getConstructor();
        System.out.println(con1);
        //得到两个参数的有参构造器：
        Constructor con2 = cls.getConstructor(double.class, double.class);
        System.out.println(con2);
        //得到一个参数的有参构造器：并且是private修饰的
        Constructor con3 = cls.getDeclaredConstructor(int.class);
        System.out.println(con3);
        //有了构造器以后我就可以创建对象：
        Object o1 = con1.newInstance();
        System.out.println(o1);
        Object o2 = con2.newInstance(180.5, 170.6);
        System.out.println(o2);
    }
}

    • 获取属性和对属性进行赋值

package com.zhaoss.test03;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
public class Test02 {
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException {
        //获取运行时类的字节码信息：
        Class cls = Student.class;
        //获取属性：
        //getFields：获取运行时类和父类中被public修饰的属性
        Field[] fields = cls.getFields();
        for(Field f:fields){
            System.out.println(f);
        }
        System.out.println("---------------------");
        //getDeclaredFields：获取运行时类中的所有属性,父类的属性不能获得
        Field[] declaredFields = cls.getDeclaredFields();
        for(Field f:declaredFields){
            System.out.println(f);
        }
        System.out.println("---------------------");
        //获取指定的属性：
        Field score = cls.getField("score");
        System.out.println(score);
        Field sno = cls.getDeclaredField("sno");
        System.out.println(sno);
        System.out.println("---------------------");
        //属性的具体结构：
        //获取修饰符
        /*int modifiers = sno.getModifiers();
        System.out.println(modifiers);
        System.out.println(Modifier.toString(modifiers));*/
        System.out.println(Modifier.toString(sno.getModifiers()));
        //获取属性的数据类型：
        Class clazz = sno.getType();
        System.out.println(clazz.getName());
        //获取属性的名字：
        String name = sno.getName();
        System.out.println(name);
        System.out.println("-------------------------------");
        //给属性赋值：(给属性设置值，必须要有对象)
        Field sco = cls.getField("score");
        Object obj = cls.newInstance();
        sco.set(obj,98);//给obj这个对象的score属性设置具体的值，这个值为98
        System.out.println(obj);
    }
}

    • 获取方法和调用方法

package com.zhaoss.test03;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
public class Test03 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //获取字节码信息：
        Class cls = Student.class;
        //获取方法：
        //getMethods:获取运行时类的方法还有所有父类中的方法（被public修饰）
        Method[] methods = cls.getMethods();
        for(Method m:methods){
            System.out.println(m);
        }
        System.out.println("-----------------------");
        //getDeclaredMethods:获取运行时类中的所有方法,父类的属性不能获得
        Method[] declaredMethods = cls.getDeclaredMethods();
        for(Method m:declaredMethods){
            System.out.println(m);
        }
        System.out.println("-----------------------");
        //获取指定的方法：
        Method showInfo1 = cls.getMethod("showInfo");
        System.out.println(showInfo1);
        Method showInfo2 = cls.getMethod("showInfo", int.class, int.class);
        System.out.println(showInfo2);
        Method work = cls.getDeclaredMethod("work",int.class);
        System.out.println(work);
        System.out.println("-----------------------");
        //获取方法的具体结构：
        /*
        @注解
        修饰符 返回值类型  方法名(参数列表) throws XXXXX{}
         */
        //名字：
        System.out.println(work.getName());
        //修饰符：
        int modifiers = work.getModifiers();
        System.out.println(Modifier.toString(modifiers));
        //返回值：
        System.out.println(work.getReturnType());
        //参数列表：
        Class[] parameterTypes = work.getParameterTypes();
        for(Class c:parameterTypes){
            System.out.println(c);
        }
        //获取注解：
        Method myMethod = cls.getMethod("myMethod");
        Annotation[] annotations = myMethod.getAnnotations();
        for(Annotation a:annotations){
            System.out.println(a);
        }
        //获取异常：
        Class[] exceptionTypes = myMethod.getExceptionTypes();
        for(Class c:exceptionTypes){
            System.out.println(c);
        }
        //调用方法：
        Object o = cls.newInstance();
        myMethod.invoke(o);//调用o对象的mymethod方法
        System.out.println(showInfo2.invoke(o,12,45));;
    }
}

    • 获取类的接口，所在包，注解

package com.zhaoss.test03;
import java.lang.annotation.Annotation;
public class Test04 {
    public static void main(String[] args) {
        //获取字节码信息：
        Class cls = Student.class;
        //获取运行时类的接口：
        Class[] interfaces = cls.getInterfaces();
        for(Class c:interfaces){
            System.out.println(c);
        }
        //得到父类的接口：
        //先得到父类的字节码信息：
        Class superclass = cls.getSuperclass();
        //得到接口：
        Class[] interfaces1 = superclass.getInterfaces();
        for(Class c:interfaces1){
            System.out.println(c);
        }
        //获取运行时类所在的包：
        Package aPackage = cls.getPackage();
        System.out.println(aPackage);
        System.out.println(aPackage.getName());
        //获取运行类的注解：
        Annotation[] annotations = cls.getAnnotations();
        for(Annotation a:annotations){
            System.out.println(a);
        }
    }
}

    • 关于反射的面试题

问题1：创建Person的对象，以后用new Person()创建,还是用反射创建？

反射只是为了提高代码的扩展性和动态性,在需要提高代码的扩展性和动态性时用反射更好,但有时代码不需要这么强的扩展性和动态性,用new创建就更好

问题2：反射是否破坏了面向对象的封装性？

private修饰符在不用反射访问时,能起到禁止访问的作用,但对于反射来说,private只是建议不要访问,用反射强行访问没有必要

一颗_豆芽菜
关注
专栏目录
第十六章：Java之反射和枚举
快乐江湖的博客
10-12 754
Java反射(reflection)：反射机制是指在运行状态中，对于任意一个类，我们都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称之为Java的反射机制在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法。
第十六章_反射机制
m0_75210916的博客
10-24 1153
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射@Inherited@Inherited。
第十六章，反射与注解
2301_76551149的博客
11-02 145
第二十三章 Java反射学习笔记
你好, 我在学java的博客
01-03 2407
2.1 反射相关的主要类4.1 Class类常用方法5. 获取类结构信息。
第十六章 反射
Zero_HWA的博客
04-08 214
反射
第一章 反射(2023版本IDEA)
2301_78884095的博客
06-27 2105
反射(Reflection)机制是Java语言特性之一，是Java被视为动态(或准动态)语言的一个关键特性。在计算机领域，反射指一种能力，能够自描述和自控制，即在运行状态中，动态获取类信息及动态调用实例方法的能力。Java反射有以下3个动态特性。运行时创建实例。运行期间调用方法。运行时更改属性。Java反射（Reflection）提供了在运行时检查和修改代码的能力，这些能力通常被称为动态特性。使用反射可以动态地获取类的名称、包、修饰符、父类、实现的接口、字段、方法等信息。Class
第二十六章：Java编程之反射
蓝不蓝编程
09-10 308
反射 Java编程中，有个有意思的东西，叫做反射，这个名字和真正的用途感觉没啥关系，不过也别埋怨翻译的水平，因为英文原文就比较奇怪。英文为Reflection，词霸翻译如下： 这个干啥用的呢？待我慢慢道来。 一般类有些属性和方法是外部不允许访问的，但是某些情况，我们却希望去修改某个类的私有属性值或者调用某个私有方法。正常途径不行，但是通过反射却可以。这也是Java动态性的一个体现，可以看看下面具体的代码： 代码简析： 第11到21行，定义了一个User类...
第二十三章 反射(reflection)
yirenyuan的博客
12-29 968
一、反射机制 | 二、Class 类 | 三、获取 Class 对象 | 四、哪些类型有 Class 对象 | 五、类加载 | 六、通过反射获取类的结构信息 | 七、通过反射创建对象 | 八、通过反射访问类中的成员 |
第16章 反射
aizhouqian5537的博客
08-07 74
通过Java反射机制，可以在程序中访问已经装载到JVM中的Java对象的描述，实现访问、检测和修改表述Java对象本身信息的功能。 Java反射机制的功能十分强大，在java.lang.reflect包中提供了对该功能的支持。 转载于:https://www.cnblogs.com/chamie/p/4710746.html...
第 16 章 反射（Reflection）
GarfieldEr007的专栏
12-18 1357
第 16 章 反射（Reflection） Java 提供的反射機制允許您於執行時期動態載入類別、檢視類別資訊、生成物件或操作生成的物件，要舉反射機制的一個應用實例，就是在整合式開發環境中所提供的方法提示或是類別檢視工具，另外像 JSP 中的 JavaBean 自動收集請求資訊也使用到反射，而一些軟體開發框架（Framework）也常見到反射機制的使用，以達到動態載入使用者自訂類別的目的。
第16章 反射1
08-08
在第16章中，我们将深入探讨Java类的加载、连接和初始化过程，以及反射的核心概念。 **16.1 类的加载、连接和初始化** 类的加载是Java程序运行的基础，它涉及到三个关键步骤： 1. **加载**：当程序首次尝试使用...
第16章 反射2
08-08
在第16章中，我们将深入探讨Java类加载、连接和初始化的过程，以及反射的相关概念。 1. **类的加载、连接和初始化** 类加载是Java运行时环境为了使用类而进行的第一步。当程序首次主动使用一个类时，如果该类尚未...
生理学第八章___尿的生成和排出试题及答案.pdf
11-16
【生理学第八章 尿的生成和排出】是医学基础知识中的重要内容，主要涉及肾脏的生理功能，尿液的形成过程，以及尿生成的调节机制。本章知识点涵盖多个专业术语和生理过程： 1. **肾单位(nephron)**：肾脏的基本功能...
ppt_第十六章1
08-04
映射优化则可能涉及反射技术，通过UML进行不断裁剪和分解。文件细化是指遵循国际统一标准，将大文件拆分成小文件，减少循环，简化内容。 【元基花的绽放与遗传】 元基花的“绽放”是指其在系统中的展示和接口调用...
Java_第17章_反射机制
qq_52922453的博客
04-17 583
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在运行期间借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
Java基本语法和基础数据类型——针对实习面试
清酒伴风的博客
11-01 934
本文主要总结了Java基本语法和基础数据类型的面试题，专门针对实习面试的同学，（水平有限，批判阅读，多多包含）
大厂面试真题-MVCC有哪些不好
个人专长：数据结构和算法、大数据、数据库、主流框架
10-30 775
MVCC（Multi-Version Concurrency Control，多版本并发控制）虽然具有提高数据库并发性能、避免脏读等优势，但也存在一些缺点。
百度集度嵌入式面试题及参考答案
大模型大数据攻城狮的专栏
10-31 817
当通过智能指针创建一个对象时，智能指针的构造函数会获取对这个对象的所有权，在智能指针的生命周期内，它会负责管理这个对象的内存。例如，在一个游戏开发中，有不同风格（如科幻风格、中世纪风格）的游戏角色和武器，抽象工厂模式可以创建不同风格的角色和武器组合，每个具体的抽象工厂子类负责创建一种风格的角色和武器。在大型软件项目的面向对象设计中，多态是实现可扩展性的关键机制。在这个类中，成员变量 data 是一个指针，它所指向的内存是在堆上分配的，当类对象被销毁时，需要在析构函数中释放这块堆内存，以避免内存泄漏。
MySQL日志——针对实习面试
最新发布
清酒伴风的博客
11-03 724
本文针对即将面试的同学，总结了MySQL日志的相关面试题及其知识点，希望对你有所帮助
Java第16章深入探讨与代码解析
资源摘要信息:"Java 第16章内容摘要及知识点分析" 一、标题解析 标题中“java第16章java-chapter16.rar”指示了该压缩包文件包含的是Java编程语言的教材或学习资料中的第16章内容。标题中的“java”表明这是Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值