当前位置:首页 > 编程教程 > java技术文章 > 关于Java中反射机制的深入讲解

Java中反射机制的知识点讲解

  • 发布时间:
  • 作者:码农之家
  • 点击:71

这篇文章主要知识点是关于java中的反射机制、java反射机制详解、java反射机制面试、的内容,如果大家想对相关知识点有系统深入的学习,可以参阅以下电子书

Java JDK 8学习笔记
Java JDK 8学习笔记全书扫描版
  • 类型:Java大小:92.3 MB格式:PDF作者:林信良
立即下载

关于Java中反射机制的深入讲解

前言

JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。

一:Class类

在面向对象的世界里,万物皆对象。类也是对象,类是java.lang.Class类的实例对象。

Class类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类,注释是一种接口。每个数组属于被映射为 Class 对象的一个类,所有具有相同元素类型和维数的数组都共享该 Class 对象。

基本的 Java 类型(boolean、byte、char、short、int、long、float 和 double)和关键字 void 也表示为 Class 对象。

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

上面来自于JDK的罗里吧嗦,下面我来说下自己的体会:

类不是抽象的,类是具体的!

类是.class字节码文件,要想获取一个Class实例对象,首先需要获取.class字节码文件!

然后调用Class对象的一些方法,进行动态获取信息以及动态调用对象方法!

二:类类型

新建一个Foo类。Foo这个类也是实例对象,是Class的实例对象。

不知道你是否在意过类的声明与方法的声明:

public class Foo{
 Foo(){
  //构造方法
 }
}
public Foo method(){
 //...
}

我们知道public后跟返回类型,也就可以知道class也是一个类型。

如何表示Class的实例对象?

 public static void main(String[] args) {
 //Foo的实例对象,new 就出来了
 Foo foo1 = new Foo();
 
 //如何表示?
 //第一种:告诉我们任何一个类都有一个隐含的静态成员变量class
 Class c1 = Foo.class;
 
 //第二种:已经知道该类的对象通过getClass方法
 Class c2 = foo1.getClass();
 System.out.println(c1 == c2);
 
 //第三种:动态加载
 Class c3 = null;
 try {
  c3 = Class.forName("cn.zyzpp.reflect.Foo");
 } catch (ClassNotFoundException e) {
  e.printStackTrace();
 }
 
 System.out.println(c2 == c3);
 }

上述打印结果全是true

尽管 c1或c2 都代表了Foo的类类型,一个类只能是Class类的一个实例变量。

我们完全可以通过类的类类型(Class类型)创建类的实例对象。

 //此时c1 c2 c3为Class的实例对象
 try {
//  Foo foo = (Foo)c1.newInstance();
  Foo foo = (Foo)c3.newInstance();
  foo.print();
 } catch (InstantiationException e) {
  e.printStackTrace();
 } catch (IllegalAccessException e) {
  e.printStackTrace();
 }

静态加载

new 创建对象是静态加载类,在编译时刻就需要加载所有的可能使用到的类 。

动态加载

使用 Class.forName("类的全称") 加载类称作为动态加载 。

编译时刻加载类是静态加载类,运行时刻加载类是动态加载类。

举个例子

定义Office类

public class Office {
 public void print() {
 System.out.println("office");
 }
}

定义Loading类

public class Loading {

 public static void main(String[] args) {
 try {
  //在运行时再动态加载类
  //arg[0] 为java执行命令时传的参数
  Class<?> a = Class.forName(args[0]);
  Office office = (Office) a.newInstance();
  office.print();
 } catch (ClassNotFoundException e) {
  e.printStackTrace();
 } catch (IllegalAccessException e) {
  e.printStackTrace();
 } catch (InstantiationException e) {
  e.printStackTrace();
 }
 }
}

执行过程

D:\>javac -encoding utf-8 Loading.java Office.java

D:\>java Loading Office
office

通过Class a=Class.forName(arg[0])动态加载获取类,因编译时不知道使用哪个类,因此编译没有加载任何类,直接通过编译,运行时,根据 java Loading Office (office是一个类类型/类,下标arg[0]),去确定a是哪个类。这就是动态加载。如果Office类不存在,此时运行会报错。这就是为何有时候会出现编译通过,运行报错的原因。

动态加载一个好处,就是可以随时增加需要编译的类。例如把Office改造为抽象类或接口,定义不同的子类,动态选择加载。

三:类的反射

通过上面的三种方法获取到类的类类型,就可以获取到该类的成员方法,成员变量,方法参数注释等信息。

方法对象是Method类,一个成员方法就是一个Method对象。

 

方法 解释
getMethods() 返回该类继承以及自身声明的所有public的方法数组
getDeclaredMethods() 返回该类自身声明的所有public的方法数组,不包括继承而来

 

成员变量也是对象,是java.lang.reflect.Field对象,Field类封装了关于成员变量的操作。

 

方法 解释
getFields() 获取所有的public的成员变量信息,包括继承的。
getDeclaredFields() 获取该类自己声明的成员变量信息,public,private等

 

获取Java语言修饰符(public、private、final、static)的int返回值,再调用Modifier.toString()获取修饰符的字符串形式,注意该方法会返回所有修饰符。

 

方法 解释
getModifiers() 以整数形式返回由此对象表示的字段的 Java 语言修饰符。

 

获取注释

 

方法 解释
getAnnotations() 返回此元素上存在的所有注释。
getDeclaredAnnotations() 返回直接存在于此元素上的所有注释。

 

构造函数也是对象,是java.lang.reflect.Constructor的对象。

 

方法 解释
getConstructors() 返回所有public构造方法
getDeclaredConstructors() 返回类的所有构造方法,不止public

 

完整示例

 private void printClassMessage(Object obj){
 //要获取类的信息,首先获取类的类类型
 Class clazz = obj.getClass();
 //获取类的名称
 System.out.println(Modifier.toString(clazz.getModifiers())+" "+ clazz.getClass().getName()+" "+clazz.getName()+"{");
 
 System.out.println("----构造方法----");
 
 //构造方法
 Constructor[] constructors = clazz.getDeclaredConstructors();
 for (Constructor constructor: constructors){
  //构造方法修饰符与名字
  System.out.print(Modifier.toString(constructor.getModifiers())+" "+constructor.getName()+"(");
  //构造函数的所有参数类型
  Class[] parameterTypes = constructor.getParameterTypes();
  for (Class c: parameterTypes){
  System.out.print(c.getName()+", ");
  }
  System.out.println("){}");
 }
 
 System.out.println("----成员变量----");
 
 //成员变量
 Field[] fields = clazz.getDeclaredFields();
 for (Field field: fields){
  System.out.println(" "+Modifier.toString(field.getModifiers())+" "+field.getType().getName() + " " + field.getName()+";");
 }
 
 System.out.println("----成员方法----");
 
 //Method类,方法对象,一个成员方法就是一个Method对象
 Method[] methods = clazz.getDeclaredMethods();
 for (Method method : methods){
  //获取方法返回类型
  Class returnType = method.getReturnType();
  //获取方法上的所有注释
  Annotation[] annotations = method.getAnnotations();
  for (Annotation annotation: annotations){
  //打印注释类型
  System.out.println(" @"+annotation.annotationType().getName()+" ");
  }
  //打印方法声明
  System.out.print(" "+Modifier.toString(returnType.getModifiers())+" "+returnType.getName()+" "+method.getName()+"(");
  //获取方法的所有参数类型
  Class<?>[] parameterTypes = method.getParameterTypes();
  //获取方法的所有参数
  Parameter[] parameters = method.getParameters();
  for (Parameter parameter: parameters){
  //参数的类型,形参(全是arg123..)
  System.out.print(parameter.getType().getName()+" "+parameter.getName()+", ");
  }
  System.out.println(")");
 }
 System.out.println("}");
 }

以String对象为例,打印结果:

public final java.lang.Class java.lang.String{
----构造方法----
public java.lang.String([B, int, int, ){}
 java.lang.String([C, boolean, ){}
----成员变量----
 private final [C value;
 private int hash;
----成员方法----
 @java.lang.Deprecated
 public abstract final void getBytes(int arg0, int arg1, [B arg2, int arg3, )
 ......
}

四:方法的反射

定义了一个类Foo用于测试

public class Foo{
 public void print(String name,int num) {
 System.out.println("I am "+name+" age "+num);
 }
}

目标:通过反射获取该方法,传入参数,执行该方法!

1.获取类的方法就是获取类的信息,获取类的信息首先要获取类的类类型

Class clazz = Foo.class;

2.通过名称+参数类型获取方法对象

Method method = clazz.getMethod("print", new Class[]{String.class,int.class});

3.方法的反射操作是通过方法对象来调用该方法,达到和new Foo().print()一样的效果

方法若无返回值则返回null

Object o = method.invoke(new Foo(),new Object[]{"name",20});

五:通过反射认识泛型

 public static void main(String[] args) {
  ArrayList<String> stringArrayList = new ArrayList<>();
  stringArrayList.add("hello");
  ArrayList arrayList = new ArrayList();
  
  Class c1 = stringArrayList.getClass();
  Class c2 = arrayList.getClass();
  
  System.out.println(c1 == c2);

 }

打印结果为true

c1==c2的结果返回说明编译之后集合的泛型是去泛型化的。换句话说,泛型不同,对类型没有影响。

Java中集合的泛型其实只是为了防止错误输入,只在编译阶段有效,绕过编译就无效。

验证

我们可以通过反射来操作,绕过编译。

 public static void main(String[] args) {
  ArrayList<String> stringArrayList = new ArrayList<>();
  stringArrayList.add("hello");
  ArrayList arrayList = new ArrayList();
  Class c1 = stringArrayList.getClass();
  Class c2 = arrayList.getClass();
  System.out.println(c1 == c2);

  try {
   Method method = c1.getMethod("add",Object.class);
   method.invoke(stringArrayList,20);
   System.out.println(stringArrayList.toString());
  } catch (NoSuchMethodException e) {
   e.printStackTrace();
  } catch (IllegalAccessException e) {
   e.printStackTrace();
  } catch (InvocationTargetException e) {
   e.printStackTrace();
  }

 }

打印结果:

true
[hello, 20]

成功绕过了泛型<String>的约束。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对码农之家的支持。

以上就是本次给大家分享的关于java的全部知识点内容总结,大家还可以在下方相关文章里找到相关文章进一步学习,感谢大家的阅读和支持。

您可能感兴趣的文章:

  • 浅析Java垃圾回收机制
  • Java程序运行机制及错误分析
  • java异常与处理机制分析
  • 关于java遍历机制性能的比较示例代码
  • java垃圾回收机制原理知识点详解
  • 相关电子书
    学习笔记
    网友NO.625133

    java反射机制Reflection详解

    Java语言有好些个名词,让人望而生畏。 上智不教即知,下愚虽教无益,中庸之人,不教不知。 人的天性中就有一点对未知的恐惧。 刚开始不了解,也没认真看,发现好难呀;等,静下心来自己研究,再看其实不难,发现都是纸老虎,不堪一击。 今天就来分析一下反射:Reflection 看一下维基百科的解释: 在诸如Java之类的面向对象的程序设计语言中,反射允许在程序运行期间访问 类、接口、字段和方法,而不必在编译期间知道接口、字段或者方法的名称。 反射也允许实例化对象和调用方法。 总结三点: 第一:反射可以获取类、接口、字段和方法的信息。 第二:不止new可以创建对象,反射也可以实例化对象。 第三:通过反射实现对方法的调用。 对于创建对象或者调用方法:正常的步骤是先用new关键词,造一个对象,然后再使用此对象的引用去调用……

    网友NO.983704

    Java对类私有变量的暴力反射技术讲解

    Java对类私有变量的暴力反射 假设有一个类,他有一个私有变量: package com.howlaa.day04;public class ReflectPoint { private int priVar; public ReflectPoint(int priVar){ this.priVar =priVar; } } 如果我们直接采用.get的方式,是不可能看到私有变量的。 我们可以这样: package com.howlaa.day04;import java.lang.reflect.Field;public class ReflectTest { public static void main(String[] args) throws Exception { ReflectPoint pt1 = new ReflectPoint(3); Field fieldx = pt1.getClass().getDeclaredField("priVar"); fieldx.setAccessible(true); fieldx.set(pt1, 100); System.out.println(fieldx.get(pt1)); }} 输出:100; 那么这个Filed是什么呢?他 是一个类,表示属性的类。通过pt1得出ReflectPoint的字节码。然后再调用 getDeclaredField 方法,可以获取x属性。再通过setAccessible使得可以访问这个属性。然后可以通过set方法赋值。注意:getClass获得是ReflectPoint的字节码,与具体实例无……

    网友NO.700312

    关于Java反射机制 你需要知道的事情

    大家都知道,要让Java程序能够运行,那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载,是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。 Java的 反射机制 是在编译并不确定是哪个类被加载了,而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 本篇将从以下几个方面讲述 反射 的知识: calss的使用 方法的反射 构造函数的反射 成员变量的反射 一、什么是class类 在面向对象的世界里,万物皆对象。类是……

    <
    1
    >

    Copyright 2018-2020 www.xz577.com 码农之家

    版权投诉 / 书籍推广 / 赞助:520161757@qq.com