Java反射机制记录

最新推荐文章于 2024-07-10 02:47:33 发布
最新推荐文章于 2024-07-10 02:47:33 发布
阅读量123 收藏
点赞数
分类专栏： JAVA JAVA反射机制
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41995919/article/details/111905148
版权

Class对象获取的三种方式

Java反射操作都需要首先获取Class对象。获取Class对象的方式有三种：

  1. 公有属性class
  2. 方法getClass()
  3. Class.forName()

示例：

public class ReflectClassDemo {
    /** log4j */
    private static final Logger LOGGER = Logger.getLogger(ReflectClassDemo.class);
    /**
    * <p>获取Class对象的三种方式</p>
    * @author*/
    public static void main(String[] args) throws ClassNotFoundException {
        LOGGER.info("获取Class对象方式01：类的public属性class");
        Class clazz1 = User.class;
        LOGGER.info(clazz1);

        System.out.println();
        LOGGER.info("获取Class对象方式02：类的public方法getClass()");
        User user = new User();
        Class clazz2 = user.getClass();
        LOGGER.info(clazz2);

        System.out.println();
        LOGGER.info("获取Class对象方法03：Class.forName（需要抛出异常）");
        Class clazz3 = Class.forName("pers.hanchao.reflect.common.User");
        LOGGER.info(clazz3);
    }
}

运行结果：

2018-02-24 13:59:06 INFO  ReflectClassDemo:18 - 获取Class对象方式01：类的public属性class
2018-02-24 13:59:06 INFO  ReflectClassDemo:20 - class pers.hanchao.reflect.common.User

2018-02-24 13:59:06 INFO  ReflectClassDemo:23 - 获取Class对象方式02：类的public方法getClass()
2018-02-24 13:59:06 INFO  ReflectClassDemo:26 - class pers.hanchao.reflect.common.User

2018-02-24 13:59:06 INFO  ReflectClassDemo:29 - 获取Class对象方法03：Class.forName（需要抛出异常）
2018-02-24 13:59:06 INFO  ReflectClassDemo:31 - class pers.hanchao.reflect.common.User

总结：

  1. 通过公有属性class获取Class对象：通过类获取，无需创建类对象。
  2. 通过方法getClass()获取Class对象：需要类的对象。常用于不知道类名但是能获取对象的情况下。
  3. 通过方法Class.forName()获取Class对象：需要类的全名，需抛出异常。常用于加载配置。

 

通过反射实例化对象的两种方式

除了通过new实例化对象，我们还可以通过反射实例化对象对象，有两种方式：

  1. Class.newInstance()
  2. Constructor.newInstance()

示例：

public class CreateObjectDemo {
    private final static Logger LOGGER = Logger.getLogger(CreateObjectDemo.class);

    /**
     * <p>Title: 通过反射创建对象的两种方式</p>
     * @author*/
    public static void main(String[] args) throws Exception {
        //通过new实例化对象
        User user = new User();
        LOGGER.info("通过new实例化对象：" + user.toString());

        //通过反射实例化对象
        Class userClass = User.class;
        //通过反射实例化对象01-Class.newInstance()（需要强制类型转换[无参构造]）
        User user1 = (User) userClass.newInstance();
        LOGGER.info("通过反射实例化对象01-Class.newInstance()（需要强制类型转换[无参构造]）：" + user1.toString());
        //通过反射实例化对象02-Constructor.newInstance()（需要强制类型转换[可带参数]）
        Constructor constructor = userClass.getDeclaredConstructor();
        User user2 = (User) constructor.newInstance();
        LOGGER.info("通过反射实例化对象02-Constructor.newInstance()（需要强制类型转换[无参构造]）：" + user2.toString());
        Constructor constructor1 = userClass.getDeclaredConstructor(String.class,String.class);
        User user3 = (User) constructor1.newInstance("李四","000000");
        LOGGER.info("通过反射实例化对象02-Constructor.newInstance()（需要强制类型转换[有参构造]）：" + user3.toString());
    }
}

补充：通过构造函数去创建，调用Constructor对象的newInstance()方法创建对象。

Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
Chinese chinese=(Chinese) c1.getConstructor().newInstance();
chinese.say();

运行结果：

2018-02-24 14:23:29 INFO  CreateObjectDemo:22 - 通过new实例化对象：User{username='张三', password='123456'}
2018-02-24 14:23:29 INFO  CreateObjectDemo:27 - 通过反射实例化对象01-Class.newInstance()（需要强制类型转换[无参构造]）：User{username='张三', password='123456'}
2018-02-24 14:23:29 INFO  CreateObjectDemo:31 - 通过反射实例化对象02-Constructor.newInstance()（需要强制类型转换[无参构造]）：User{username='张三', password='123456'}
2018-02-24 14:23:29 INFO  CreateObjectDemo:34 - 通过反射实例化对象02-Constructor.newInstance()（需要强制类型转换[有参构造]）：User{username='李四', password='000000'}

总结：

  1. 通过Class.newInstance()进行对象实例化：实际调用的是无参数的构造函数进行实例化。
  2. 通过Constructor.newInstance()进行对象实例化：可以选择调用哪个构造函数进行实例化。

 

获取某个类的所有构造方法

public class ReflectTest1 {
    public static void main(String[] args) {
        Date date = new Date();
        Class cc = date.getClass();
        String className = cc.getName();
        System.out.println(className);
        Constructor[] declaredConstructors = cc.getDeclaredConstructors();
        for (Constructor constructor : declaredConstructors) {
            int modifiers = constructor.getModifiers();
            System.out.print(Modifier.toString(modifiers) + " ");
            System.out.print(constructor.getName() + "(");
            Class[] paramTypes = constructor.getParameterTypes();
            for (Class paramType : paramTypes) {
                System.out.print(paramType.getName() + " ");
            }
            System.out.println(")");
        }
    }
}

输出结果：

java.util.Date
public java.util.Date(java.lang.String )
public java.util.Date(int int int int int int )
public java.util.Date(int int int int int )
public java.util.Date()
public java.util.Date(long )
public java.util.Date(int int int )

获取某个类的所有属性信息

public class ReflectTest2 {
    public static void main(String[] args) {
        Date date = new Date();
        Class cc = date.getClass();
        String className = cc.getName();
        System.out.println(className);
        Field[] fields = cc.getDeclaredFields();
        for (Field field : fields) {
            String modifiers = Modifier.toString(field.getModifiers());
            Class type = field.getType();
            String name = field.getName();
            System.out.println(modifiers + " " + type.getName() + " " + name);
        }
    }
}

输出结果：

java.util.Date
private static final sun.util.calendar.BaseCalendar gcal
private static sun.util.calendar.BaseCalendar jcal
private transient long fastTime
private transient sun.util.calendar.BaseCalendar$Date cdate
private static int defaultCenturyStart
private static final long serialVersionUID
private static final [Ljava.lang.String; wtb
private static final [I ttb

补充：

1、获取所有非private类型的字段，包括父类的
     Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
     Object object=    c1.getConstructor().newInstance();
     Field [] fields=  c1.getFields();//或者所有的非private类型的字段，包括父类的
     for(int i=0;i<fields.length;i++)
     {
         System.out.println(fields[i].getName());
     }
     
2、获取当前类所有字段，包括私有的
     Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
     Object object=    c1.getConstructor().newInstance();
     Field [] fields=  c1.getDeclaredFields();//获取当前类中所有的字段
     for(int i=0;i<fields.length;i++)
     {
         System.out.println(fields[i].getName());
     }
     
3、获取父类的所有字段，包括私有的

        Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
        Class c2=    c1.getSuperclass();
        //通过c2去获取父类中的私有字段
4、获取指定的字段
     Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
     Object object=    c1.getConstructor().newInstance();
     Field field=  c1.getDeclaredField("Age");

5、使用
     Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
     Object object1=    c1.getConstructor().newInstance();
     Field field=  c1.getDeclaredField("Age");
     field.setAccessible(true);//如果字段是私有的，需要先这是允许访问
     //取值
     Object  object2=field.get(object1);
     System.out.println(object2);
     //赋值
     field.set(object1, 21);
     //取值
     Object  object3=field.get(object1);
     System.out.println(object3);

获取某个类的所有方法信息

public class ReflectTest3 {
    public static void main(String[] args) {
        Date date = new Date();
        Class cc = date.getClass();
        Method[] methods = cc.getDeclaredMethods();
        for (Method method : methods) {
            String modifiers = Modifier.toString(method.getModifiers());
            Class returnType = method.getReturnType();
            String name = method.getName();
            Class[] parameterTypes = method.getParameterTypes();
            Class[] exceptions = method.getExceptionTypes();
            System.out.println(modifiers + " " + returnType + " " + name
                    + "(" + Arrays.asList(parameterTypes) + ")throws" + Arrays.asList(exceptions));
        }
    }
}

输出结果：

public boolean after([class java.util.Date])throws[]
public boolean before([class java.util.Date])throws[]
public boolean equals([class java.lang.Object])throws[]
public class java.lang.String toString([])throws[]
public int hashCode([])throws[]
public class java.lang.Object clone([])throws[]
public volatile int compareTo([class java.lang.Object])throws[]
public int compareTo([class java.util.Date])throws[]
······

补充：获取方法并执行

1、获取所有的非private方法
        Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
        Object chinese= c1.getConstructor().newInstance();
        Method[] methods1= c1.getMethods();//获取所有的非private方法，并且父类的方法也会获取
        for(int i=0;i<methods1.length;i++)
        {
            Class[] parameters= methods1[i].getParameterTypes();
            if(parameters.length<=0)
            {
                 System.out.println(methods1[i].getName()+"()");
            }
            else
            {
                String [] typeName=new String[parameters.length];
                for(int j=0;j<parameters.length;j++)
                {
                    
                    typeName[j]=parameters[j].getSimpleName();
                }
                System.out.println(methods1[i].getName()+"("+String.join(",",typeName)+")");
            }

        }

2、获取所有的当前类定义的所有方法，包括私有方法
        Method[] methods1= c1.getDeclaredMethods();//获取当前类定义的所有，包括私有方法
3、获取指定方法名的方法
        Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
        Object chinese= c1.getConstructor().newInstance();
        Method setNumber=    c1.getDeclaredMethod("setNumber", Integer.class);//如果方法没有参数就可以不用写，另外需要注意参数类型和定义方法的参数类型保持一致

4、获取父类的私有方法
        Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
        Class c2=    c1.getSuperclass();
        //通过c2去获取父类中的私有方法

5、执行方法
        Class c1=Class.forName("pers.pwz.cmdemo.Chinese");
        Object chinese= c1.getConstructor().newInstance();
        Method setNumber=    c1.getDeclaredMethod("setNumber", Integer.class);//如果方法没有参数就可以不用写，另外需要注意参数类型和定义方法的参数类型保持一致
        setNumber.invoke(chinese, 1);    //第一个参数是实例对象，后面的参数是调用方法所需的参数

 

动态代理

代理是基本的设计模式之一。
下面是一个用来展示代理结构的简单示例：

interface Interface {
  void doSomething();
  void somethingElse(String arg);
}

class RealObject implements Interface {
  public void doSomething() { System.out.println("doSomething"); }
  public void somethingElse(String arg) {
    System.out.println("somethingElse " + arg);
  }
}    

class SimpleProxy implements Interface {
  private Interface proxied;
  public SimpleProxy(Interface proxied) {
    this.proxied = proxied;
  }
  public void doSomething() {
    System.out.println("SimpleProxy doSomething");
    proxied.doSomething();
  }
  public void somethingElse(String arg) {
    System.out.println("SimpleProxy somethingElse " + arg);
    proxied.somethingElse(arg);
  }
}    

class SimpleProxyDemo {
  public static void consumer(Interface iface) {
    iface.doSomething();
    iface.somethingElse("bonobo");
  }
  public static void main(String[] args) {
    consumer(new RealObject());
    consumer(new SimpleProxy(new RealObject()));
  }
}

输出结果：

doSomething
somethingElse bonobo
SimpleProxy doSomething
doSomething
SimpleProxy somethingElse bonobo
somethingElse bonobo

Java的动态代理比代理的思想更向前迈进了一步，因为它可以动态地创建代理并动态地处理对所代理方法的调用。在动态代理所做的所有调用都会被重定向到单一的调用处理器上。

import java.lang.reflect.*;

class DynamicProxyHandler implements InvocationHandler {
  private Object proxied;
  public DynamicProxyHandler(Object proxied) {
    this.proxied = proxied;
  }
  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);
  }
}

输出结果：

doSomething
somethingElse bonobo
**** proxy: class $Proxy0, method: public abstract void Interface.doSomething(), args: null
doSomething
**** proxy: class $Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@53bd815b
  bonobo
somethingElse bonobo

通过调用静态方法Proxy.newProxyInstance()可以创建动态代理，这个方法需要得到一个类加载器。
动态代理可以将所有调用重定向到调用处理器，因此通常会向调用处理器的构造器传递给一个“实际”对象的引用，从而使得调用处理器在执行其中任务时，可以将请求转发。

空对象

当你使用内置的null表示缺少对象时，在每次使用引用时都必须测试其是否为null，这显得枯燥，而且势必产生相当乏味的代码。问题在于null除了在你试图用它执行任何操作来产生NullPointerException之外，它自己没有其他任何行为。有时引入空对象的思想将会很有用，它可以接受传递给它的所代表的对象的消息，但是将返回表示为实际上并不存在任何“真实”对象的值。通过这种方式，你可以假设所有的对象都是有效的，而不必浪费编程精力去检查null。
推荐阅读：java设计模式之空对象模式

图图小淘气_real
关注
专栏目录
Java反射02 : Class对象获取的三种方式和通过反射实例化对象的两种方式
韩超的博客 (hanchao5272)
02-24 6300
[超级通道 : Java反射学习系列-绪论] 1.Class对象获取的三种方式 上一章节已经说过，一般情况下，Java反射操作都需要首先获取Class对象。获取Class对象的方式有三种。 公有属性class 方法getClass() Class.forName() 下面是示例代码： /** * &lt;p&gt;Title: Java获取Class对象的三种方式&lt;/...
java 的class类获取实例的三种方法
热门推荐
mvpme82的专栏
07-27 1万+
java 的class类获取实例的三种方法，在单元测试中有着非常灵活的使用，具体定义如下： Class类（在java.lang包中，Instances of the class Classrepresent classes and interfaces in a running Javaapplication）：    在Java中，每个class都有一个相应的Class对象。也就是说，当
java 根据类名获取实例
最新发布
weixin_37007062的博客
07-10 173
Java 根据类名获取实例 概述 在 Java 中，我们可以通过反射机制实现根据类名获取实例的功能。反射是 Java 的一项强大的特性，能够在运行时获取类的信息并进行操作。这对于一些需要动态加载类的场景非常有用，比如插件化开发、工厂模式等。 流程 下面是获取实例的整个流程，我们可以通过表格来展示： 步骤 操作 ...
第二课 Class类的理解
Yorick.Xu的技术进化史
08-27 399
Class类的理解1 类的加载过程2 获取Class实例的方式3 有Class对象的类型4 类的加载过程5 ClassLoader6 创建运行时类的对象及动态性演示 1 类的加载过程 程序经过javac.exe命令编译后，产生一个或多个字节码文件(.class文件) 使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中，此过程称为类的加载。加载到内存中的类，称之为运行时类，此运行时类就作为Class的一个实例 加载到内存中的运行时类，会缓存一定的时间，在此时间之内，我们
class类获取实例的三种方法
兴趣在哪，成功就在哪！
03-12 1755
在Java中，每个class都有一个相应的Class对象。当一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。  在运行阶段，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该
JAVA反射机制实例教程
09-04
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。通过反射，开发者可以访问和修改私有成员，调用私有方法，创建对象，以及对类、接口、字段和方法进行操作，极大地...
Java反射机制及Method.invoke详解
09-03
Java反射机制是Java核心特性之一，它允许程序在运行时动态地获取类的信息并操作类的对象。这使得Java具备了高度的灵活性和可扩展性，特别是在处理动态加载类、插件系统、序列化、框架设计等领域有着广泛的应用。 1....
Java反射机制
02-27
### Java反射机制详解 #### 一、什么是Java的反射机制 Java反射机制是Java语言的一种重要特性，使得Java成为了一种动态性很强的语言。通过反射，可以在程序运行时获取类的信息，包括类名、父类、接口、字段、方法...
java反射机制
05-23
Java反射机制是在运行时通过Reflection APIs获取任何已知类的内部信息，包括类的修饰符（如public、static等）、超类、实现的接口、字段和方法的全部信息。它还允许在运行时改变字段内容、调用方法，甚至创建未知类...
获取Class实例的方式
weixin_43740054的博客
10-09 142
关于java.lang.Class类的理解 1.类的加载过程 程序经过Javac.exe命令以后，会生成一个或多个字节码文件(.class结尾) 接着使用java.exe命令对字节码文件进行解释运行。相当于将某个字节码我呢见加载到内存中去，此过程称为类的加载 加载到内存中的类，成为运行时类，此运行时类就作为Class的一个实例 2.Class的实例就对应着一个运行时类 3.加载到内存中的运行时类，会缓存一定的时间，期间可以通过不同的方式来获取此运行时类。 获取Class实例的方式 //方式一：调用运行时
获取Class实例的四种方式
fighting32的博客
06-30 745
类的加载过程 程序在经过javac.exe命令后会生成一个或多个字节码文件（.class结尾的文件），接着使用java.exe命令对字节码文件进行解释运行，这时候就把字节码文件加载到内存中。加载到内存中的类成为运行时类，运行时类是Class的实例。 @Test public void test() throws ClassNotFoundException { //方式1：调用运行时类的属性 .class Class cla1 = person.class; System.out
JAVA中获取Class实例的三种方法
qq_45148387的博客
03-25 711
要操作一个类的字节码，需要现货区这个类的字节码，下面是三种获取的方法： / 第一种： /* 第一种方式： 使用Class.forName()方法; 1、静态方法 2、方法的参数是一个字符串。 3、字符串需要是一个完整的类名。 4、完整雷鸣必须带有包名。java.lang包不能省略。 */ public class ThreadTest11 { public static void main(String[] args){
【注释和反射】获取class类实例的方法
水w的博客
04-24 1344
获取class类实例的方法
Java 反射 - 获取Class实例的3种方式
牧小七的博客
06-25 212
运行时类在内存中会缓存起来，在整个执行期间，只会加载一次。
java反射之获取Class实例的4中方法
weixin_45713608的博客
11-07 720
java反射之获取Class实例的4中方法
java中利用反射实现的几个小示例
...
02-08 785
上篇文章中我简单介绍了在java中使用反射机制的几个常用的方式和方法。现在我们就以实际应用来拓展下使用反射机制，我会通过两个小题目来演示关于反射的实际应用。 （1）将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的“h”替换成"a"。 其实这道题目很简单，要将一个类的所有成员变量为String类型的，并且字符串中包含“h”的要替换成"a"。 此处要获取所有成员变量，就要调
反射的三种方式及利用反射创建对象
qq_43148324的博客
01-26 6329
传统方式 普通方法也就是最常见的创建对象的方法 前提条件：知道存在这个类，且这个类叫Object 例： Object obj=new Object(); 利用反射创建对象 方式一：通过类名.class方式 前提条件：需要在编译时就知道存在Object类 例： Class<?> obj1 = Object.class; 方式二：通过已知对象实例.getClass方式 前提条件：存在该类创建的已知对象，且需要在编译时就知道存在Object类 例：此处已通过普通(传统)方式创建了对象obj Cla
反射机制--获取实例化对象
白净垃圾桶-
05-11 1351
在上一节中，获取到了字节码文件对象，那么如何获取该字节码文件对应的Person对象呢？（仍然使用在text包下定义的Person类。） 运行早期的方法： package text; public class ReflectDemo2 { public static void main(String[] args) throws ClassNotFoundException, Instan
Java反射机制深入解析
"Java反射机制是Java编程语言中的一个重要特性，允许程序在运行时检查类、接口、字段和方法的信息，并能动态地修改字段内容或调用方法。本文通过实例详细介绍了Java反射API的使用，适合具备Java语言基础的读者学习。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

图图小淘气_real

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值