JAVA反射

最新推荐文章于 2023-07-13 00:30:40 发布
最新推荐文章于 2023-07-13 00:30:40 发布
阅读量339 收藏
点赞数 2
分类专栏： # 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heijunwei/article/details/111317458
版权

目录

 

一、概念：

二、反射的作用

三、JAVA 反射API

1、Class类：反射的核心类，可以获取类的属性，方法等信息。

2、Field类：Java.lang.reflec包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。

3、Method类：Java.lang.reflec包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。

4、Constructor类：Java.lang.reflec包中的类，表示类的构造方法。

5、获取继承关系

四、反射应用（动态代理）

五、Optional类（轻量级代理）

一、概念：

      “反射”机制：允许我们在运行时发现和使用类的信息。指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为Java语言的反射机制。

从反射角度说JAVA属于半动态语言，动态语言，是指程序在运行时可以改变其结构：新的函数可以引进，已有的函数可以被删除等结构上的变化。比如常见的JavaScript就是动态语言，除此之外Ruby,Python等也属于动态语言，而C、C++则不属于动态语言。

二、反射的作用

  •  反射是为了解决在运行期，对某个实例一无所知的情况下，如何调用其方法。
  •  编译时类型和运行时类型，在Java程序中许多对象在运行是都会出现两种类型：编译时类型和运行时类型。编译时的类型由声明对象时使用的类型来决定，运行时的类型由实际赋值给对象的类型决定。如：
Fruit fruit = new Apple();

 其中编译时类型为Fruit，运行时类型为Apple；在编译时fruit无法获取apple具体方法（非继承）。

  •  程序在运行时还可能接收到外部传入的对象，该对象的编译时类型为Object,但是程序有需要调用该对象的运行时类型的方法。为了解决这些问题，程序需要在运行时发现对象和类的真实信息。然而，如果编译时根本无法预知该对象和类属于哪些类，程序只能依

   靠运行时信息来发现该对象和类的真实信息，此时就必须使用到反射了。

三、JAVA 反射API

1、Class类：反射的核心类，可以获取类的属性，方法等信息。

  • Java的类型全部都是class（除了基本类型外),所以class（包括interface）的本质是数据类型（Type）。无继承关系的数据类型无法赋值：而class是由JVM在执行过程中动态加载的。
  • JVM在第一次读取到一种class类型时，将其加载进内存，每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。

        注意：这里的Class类型是一个名叫Class的class。它长这样：

public final class Class {
    private Class() {}
}

      以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：
      Class cls = new Class(String);

     
       这个Class实例是JVM内部创建的，如果我们查看JDK源码，可以发现Class类的构造方法是private，只有JVM能创建Class实例，我们自己的Java程序是无法创建Class实例的。所以，JVM持有的每个Class实例都指向一个数据类型（class或interface）： 由于          JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。

  •      获取Class对象的3种方法

            1、调用某个对象的getClass()方法

                 Person p=new Person();

                 Class clazz=p.getClass();

           2、调用某个类的class属性来获取该类对应的Class对象

                Class clazz=Person.class;

            3、使用Class类中的forName()静态方法(最安全/性能最好)

                Class clazz=Class.forName("类的全路径"); (最常用)

            当我们获得了想要操作的类的Class对象后，可以通过Class类中的方法获取并查看该类中的方法和属性。

  •  动态加载应用
// Commons Logging优先使用Log4j:
LogFactory factory = null;
if (isClassPresent("org.apache.logging.log4j.Logger")) {
    factory = createLog4j();
} else {
    factory = createJdkLog();
}

boolean isClassPresent(String name) {
    try {
        Class.forName(name);
        return true;
    } catch (Exception e) {
        return false;
    }
}

       这就是为什么我们只需要把Log4j的jar包放到classpath中，Commons Logging就会自动使用Log4j的原因。

 

2、Field类：Java.lang.reflec包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。

  •     获取属性API
  1.  Field getField(name)：根据字段名获取某个public的field（包括父类）
  2.  Field getDeclaredField(name)：根据字段名获取当前类的某个field（不包括父类）
  3.  Field[] getFields()：获取所有public的field（包括父类）
  4.  Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
  •     一个Field对象包含了一个字段的所有信息：
  1. getName()：返回字段名称，例如，"name"；
  2. getType()：返回字段类型，也是一个Class实例，例如，String.class；
  3. getModifiers()：返回字段的修饰符，它是一个int，不同的bit表示不同的含义。
  •  Field.setAccessible(true)的意思是，别管这个字段是不是public，一律允许访问
public class Fruit {
    private String name;

    public Fruit() {
    }

    public Fruit(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

class Apple extends Fruit {
    public int color;
    private int shape ;
}


public class FruitTest {
    @Test
    public void test() throws NoSuchFieldException, IllegalAccessException {
        Class appleClass = Apple.class;
        // 获取public字段"color":
        System.out.println(appleClass.getField("color"));
        // 获取继承的public字段"name":
//        System.out.println(appleClass.getField("name"));
        // 获取private字段"shape":
        System.out.println(appleClass.getDeclaredField("shape"));

        // 获取所有public的field（包括父类）
        List<Field> fields = Arrays.asList(appleClass.getFields());
        for (Field field: fields) {
            System.out.println(field);
        }

        // 获取当前类的所有field（不包括父类）
        List<Field> declaredfields = Arrays.asList(appleClass.getDeclaredFields());
        for (Field field: declaredfields) {
            System.out.println(field);
        }

        // 获取public字段"color":
        Field field = appleClass.getField("color");
        // 返回字段名称
        System.out.println(field.getName());
        // 返回字段类型
        System.out.println(field.getType());
        // 返回字段的修饰符
        System.out.println(field.getModifiers());
        int m = field.getModifiers();
        Modifier.isFinal(m); // false
        Modifier.isPublic(m); // true
        Modifier.isProtected(m); // false
        Modifier.isPrivate(m); // true
        Modifier.isStatic(m); // false

        // 获取字段值
        Object obj = new Fruit("ping guo");
        Class objClass = obj.getClass();
        Field name = objClass.getDeclaredField("name");
        name.setAccessible(true);
        Object value = name.get(obj);
        System.out.println(value); // "ping guo"

        // 设置字段值
        Fruit fruit = new Fruit("ping guo");
        System.out.println(fruit.getName());
        Class c = fruit.getClass();
        Field f = c.getDeclaredField("name");
        f.setAccessible(true);
        f.set(fruit, "Xiao jiao");
        System.out.println(fruit.getName());


    }

}

3、Method类：Java.lang.reflec包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。

  • 获取Method API；
  1. getName()：返回方法名称，例如："getScore"；
  2. getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；
  3. getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；
  4. getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。
  • 获取Method方法信息API
  1. getName()：返回方法名称，例如："getScore"；
  2. getReturnType()：返回方法返回值类型，也是一个Class实例，例如：String.class；
  3. getParameterTypes()：返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}；
  4. getModifiers()：返回方法的修饰符，它是一个int，不同的bit表示不同的含义。
  • 调用方法，：Object invoke(Object instance, Object... parameters)；
  • 调用静态方法，由于无需指定实例对象，所以invoke方法传入的第一个参数永远为null
  • 调用非public方法，通过设置setAccessible(true)来访问非public方法；
  • 使用反射调用方法时，仍然遵循多态原则

    

public class Person {
    public String getName() {
        return "xiaom";
    }
}

class Student extends Person {
    public int getScore(String type) {
        return 100;
    }
    private int getGrade(int year) {
        return 6;
    }
}

public class PersonTest {
    @Test
    public void test() throws Exception {
        Class stdClass = Student.class;
        // 获取public方法getScore，参数为String:
        System.out.println(stdClass.getMethod("getScore", String.class));
        // 获取继承的public方法getName，无参数:
        System.out.println(stdClass.getMethod("getName"));
        // 获取private方法getGrade，参数为int:
        System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));


        /**
         * 调用方法
         */
        // String对象:
        String s = "Hello world";
        // 获取String substring(int)方法，参数为int:
        Method m = String.class.getMethod("substring", int.class);
        // 在s对象上调用该方法并获取结果:
        String r = (String) m.invoke(s, 6);
        // 打印调用结果:
        System.out.println(r);


        /**
         * 调用静态方法
         */
        // 获取Integer.parseInt(String)方法，参数为String:
        Method method = Integer.class.getMethod("parseInt", String.class);
        // 调用该静态方法并获取结果:
        Integer n = (Integer) method.invoke(null, "89898");
        // 打印调用结果:
        System.out.println(n);

        /**
         *  调用非public方法
         */

        Car car = new Car();
        Method staticMethod = car.getClass().getDeclaredMethod("setName", String.class);
        staticMethod.setAccessible(true);
        staticMethod.invoke(car, "宝马");
        System.out.println(car.name);
        
    }
}

4、Constructor类：Java.lang.reflec包中的类，表示类的构造方法。

  • 获取构造方法API
  1. getConstructor(Class...)：获取某个public的Constructor；
  2. getDeclaredConstructor(Class...)：获取某个Constructor；
  3. getConstructors()：获取所有public的Constructor；
  4. getDeclaredConstructors()：获取所有Constructor。
  • 创建对象
  1. 使用Class对象的newInstance()方法来创建该Class对象对应类的实例，但是这种方法要求该Class对象对应的类有默认的空构造器。
  2. 先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建Class对象对应类的实例,通过这种方法可以选定构造方法创建实例。
//获取Person类的Class对象
Class clazz=Class.forName("reflection.Person"); 
//使用.newInstane方法创建对象
Person p=(Person) clazz.newInstance();
//获取构造方法并创建对象
Constructor c=clazz.getDeclaredConstructor(String.class,String.class,int.class);
//创建对象并设置属性
Person p1=(Person) c.newInstance("张三","女",18);

5、获取继承关系

通过Class对象可以获取继承关系：

  • Class getSuperclass()：获取父类类型；
  • Class[] getInterfaces()：获取当前类实现的所有接口。

通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现。

 

四、反射应用（动态代理）

  •  代理是基本的设计模式之一。一个对象封装真实对象，代替其提供其他或不同的操作---这些操作通常涉及到与“真实”对象的通信，因此代理通常充当中间对象。不仅动态创建代理对象而且动态处理对代理方法的调用。在动态代理上进行的所有调用都被重定向到单个调用处理程序，该处理程序负责发现调用的内容并决定如何处理。
  •  比较Java的class和interface的区别，可以实例化class（非abstract）；不能实例化interface，标准库提供了一种动态代理（Dynamic Proxy）的机制：可以在运行期动态创建某个interface的实例 
  •  在运行期动态创建一个interface实例的方法如下：
  1. 定义一个InvocationHandler实例，它负责实现接口的方法调用；
  2. 通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：

         使用的ClassLoader，通常就是接口类的ClassLoader；

         需要实现的接口数组，至少需要传入一个接口进去；

         用来处理接口方法调用的InvocationHandler实例。

    3.  将返回的Object强制转型为接口。

import java.lang.reflect.*;

class DynamicProxyHandler implements InvocationHandler {
    private Object proxied;

    DynamicProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    @Override
    public Object
    invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println(
                "**** proxy: " + proxy.getClass() +
                        ", method: " + method + ", args: " + args);
        if (args != null)
            for (Object arg : args)
                System.out.println("  " + arg);
        return method.invoke(proxied, args);
    }
}

class SimpleDynamicProxy {
    public static void consumer(Interface iface) {
        iface.doSomething();
        iface.somethingElse("bonobo");
    }

    public static void main(String[] args) {
        RealObject real = new RealObject();
        consumer(real);
        // Insert a proxy and call again:
        Interface proxy = (Interface) Proxy.newProxyInstance(
                Interface.class.getClassLoader(),
                new Class[]{Interface.class},
                new DynamicProxyHandler(real));
        consumer(proxy);
    }
}

 

五、Optional类（轻量级代理）

         Optional 是 Java 8 为了支持流式编程才引入的，Optional 对象可以防止你的代码直接抛出 NullPointException。实际上，在所有地方都使用 Optional 是没有意义的，有时候检查一下是不是 null 也挺好的，或者有时我们可以合理地假设不会出现 null，甚至有时候检查 NullPointException 异常也是可以接受的。Optional 最有用武之地的是在那些“更接近数据”的地方，在问题空间中代表实体的对象上。举个简单的例子，很多系统中都有 Person 类型，代码中有些情况下你可能没有一个实际的 Person 对象（或者可能有，但是你还没用关于那个人的所有信息）。这时，在传统方法下，你会用到一个 null 引用，并且在使用的时候测试它是不是 null。而现在，我们可以使用 Optional：

class Person {
    public final Optional<String> first;
    public final Optional<String> last;
    public final Optional<String> address;
    // etc.
    public final Boolean empty;

    Person(String first, String last, String address) {
        this.first = Optional.ofNullable(first);
        this.last = Optional.ofNullable(last);
        this.address = Optional.ofNullable(address);
        empty = !this.first.isPresent()
                && !this.last.isPresent()
                && !this.address.isPresent();
    }

    Person(String first, String last) {
        this(first, last, null);
    }

    Person(String last) {
        this(null, last, null);
    }

    Person() {
        this(null, null, null);
    }

    @Override
    public String toString() {
        if (empty)
            return "<Empty>";
        return (first.orElse("") +
                " " + last.orElse("") +
                " " + address.orElse("")).trim();
    }

    public static void main(String[] args) {
        System.out.println(new Person());
        System.out.println(new Person("Smith"));
        System.out.println(new Person("Bob", "Smith"));
        System.out.println(new Person("Bob", "Smith",
                "11 Degree Lane, Frostbite Falls, MN"));
    }
}

 

心灵彼岸-诗和远方
关注
专栏目录
java 反射
12-22
这种动态获取信息以及动态调用对象方法的功能成为java反射机制。 2. java 文件和 .class 文件的关系 java 文件 java文件中包含代码的所有内容，类，接口，成员变量，成员方法.... .class 字节码文件 .class 是由 ...
反射——Java学习笔记
编程大白菜
10-08 236
反射反射概述哪些类有Class对象获得Class从Class中获取信息获取包名和类型名获取属性获取方法获取构造器获取类的加载器获取类型修饰符获取父类或父接口获取内部类或外部类信息获取泛型父类获取注解信息使用反射生成对象并操作使用反射创建对象获取、设置属性值调用方法操作数组 反射概述 Java反射机制是运行状态中，对于任意一个类，都能够知道这个类的所有的属性和方法，对于任意一个对象，都能够调用它的任意方法和属性，这种动态获取信息以及动态调用对象的方法就被称为Java语言的反射机制 java程序中，所有对象都有
Java中的反射（详细介绍）
m0_69855013的博客
08-18 874
Java中的反射（详细介绍）
Java中反射相关的类
XHT117的博客
06-01 2633
目录反射反射相关的类1. Class类——反射核心类2. Constructor类——通过反射调用构造方法破坏封装对象3. Method类——通过反射调用普通方法4. Field类——通过反射调用属性
java 基本类型 反射_使用Java反射机制确定基本数据类型属性
weixin_36124750的博客
02-15 467
该楼层疑似违规已被系统折叠隐藏此楼查看此楼Java反射机制提供了一种强大的应用程序接口来帮助我们在运行时检测和执行对象上的操作。该机制允许程序员审视一个未知对象，并且获得它的属性，例如对象上的方法，JavaBean的属性以及继承关系等。Java中有两种类型的值，一种是类类型，它把对象的属性定义在一个类中。类类型是面向对象结构的基本组成部分。第二种类型的值是基本数据类型。反射类型通常用于类类型，但...
Java反射基础——四大核心类
有人_295的博客
05-17 1176
反射是框架设计的灵魂 （使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）） 反射就是把java类中的各种成分映射成一个个的Java对象 例如：一个类有：成员变量、方法、构造方法、包等等信息，利用反射技术可以对一个类进行解剖，把个个组成部分映射成一个个对象。 （其实：一个类中这些成员方法、构造方法、在加入类中都有一个类来描述） 如图是类的正常加载过程...
Java反射案例
01-09
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制的核心类集中在java.lang.reflect包下，包括Class、Constructor、Method和Field...
详解JAVA 反射机制
08-19
Java 反射机制详解 Java 反射机制是 Java 语言中一个非常强大且灵活的机制，它允许在运行时获取类的信息、创建对象、调用方法和访问成员变量等。反射机制在 Java 中的应用非常广泛，例如在框架中，如 Spring、...
深入理解Java反射
09-01
Java反射是Java编程语言的一个重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。在深入探讨反射之前，我们先要明白类型信息的概念。类型信息是指在程序运行时，关于类、接口、对象的具体信息，包括...
Java反射实例
09-10
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java中，反射机制的核心类是`java.lang.Class`，它代表了类的信息。通过反射，我们可以动态地...
[java]反射四大类的基本用法
qq_61925446的博客
04-12 695
我们都知道，我们编写好的java代码文件时.java文件，要想运行这个.java文件，就要通过编译器编译，编译器会讲.java文件编译成.class文件，并且每一个类对应一个.class文件，就算一个.java文件中，定义了两个类，编译器就会将一个java文件，编译成两个.class文件.反射的核心就是四个类，Class,Method,Constructor,Filed，这四个类分别对应类，类的方法，类的构造方法，类的成员变量,需要先获得Class对象才能获得剩下的三个类对象。
【Java 基础篇】Java 反射详解
繁依Fanyi的博客
06-27 7162
Java反射是一种强大的特性，它允许程序在运行时动态地获取和操作类的信息。通过反射，我们可以创建对象、调用方法和访问字段，而不需要提前知道类的具体定义。反射在许多框架和工具中被广泛应用，具有重要的作用。希望本文对你理解和使用Java反射有所帮助！通过灵活应用反射机制，你可以在Java开发中更加灵活和高效地实现各种功能。
java基础之反射类型Type
m0_68064743的博客
04-04 4407
Java在加入泛型之后，仅仅Class已经不足以描述数据的类型了，比如List类型的数据，其Class的类型为List.class，但是其类型包含了泛型参数，所以java引入了Type类型来描述泛型类型。除了泛型类型，还有数组格式的数据，其类型也包含两部分，一部分是数组对象本身的class，另外一部分是数组中数据的类型。本文会详细介绍JavaType中的各种类型，分析这些类型的使用方法。 Type介绍 Type是Java 编程语言中所有类型的公共高级接口，也就是Java中所有"类型"的接口。官方原话定义如下
java反射三种实现方式
qq_64897221的博客
05-18 1798
介绍java反射的三种实现方式
Java反射详解
热门推荐
weixin_74268571的博客
06-22 2万+
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.反射就是把java类中的各种成分映射成一个个的Java对象。
java反射的三种方式，获取 属性、方法、构造方法 简单明了
weixin_56654434的博客
11-10 3956
反射的三种方式，获取全部属性、方法、构造方法
反射和属性
weixin_30678349的博客
07-17 129
•反射的概念 •反射遍历成员 •用射调用类型成员 •属性概念（Attribute） •属性的实例 •自定议属性 •三个属性 二次编辑一次运行 一次编译后 反射 反射是编程的读取与类型相关联的元数据的行为。通读取元数据，可以了解它是什么类型以及类型的成员。比如类中的属性，方法，事件等。 所属命名空间System.Reflection 反射-反射成员名称 类 c...
Java反射机制部分总结
最新发布
weixin_62226624的博客
07-13 457
Java反射机制是指是在运行期中，对于任意一个类，都能够得到这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。根据类名，就可以通过该类的newInstance()方法创建对象。1.JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用到class时才加载。2.通过getConstructor（传入参数类型的不同）得到有参或者无参（不传参）构造方法。
java基础之反射
hjkl761的博客
03-11 349
对于 Class 对象，构造方法的名称是【类名】，不具备唯一性。在实际调用构造方法，区分构造方法的不同是通过【参数列表，参数数据类型，参数个数，参数顺序】来区分！！！Method 成员方法类型，通过 Class 对象获取关注点是【方法名】和【形式参数列表】针对于类内的成员变量，唯一的标识【成员变量名】
深入理解Java反射机制
"Java反射机制是Java编程中的重要特性，它允许程序在运行时动态地获取类的信息并操作类的对象。通过Java反射，开发者可以在不知道具体类名的情况下，对类进行实例化，调用方法，访问和修改属性，实现更加灵活的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值