java 反射和内省

最新推荐文章于 2022-07-17 16:57:44 发布
最新推荐文章于 2022-07-17 16:57:44 发布
阅读量1.6k 收藏 2
点赞数
分类专栏： java（基础知识） 文章标签： java class string object constructor methods
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxdyynn163/article/details/2622736
版权

1       反射和内省

反射 (Reflection) ， JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。
内省 (Introspector) ，是“看透 class ”的能力（内省、内观、反省）。
2.1    “Class” object的取得途径
Java 允许我们从多种管道为一个 class 生成对应的 Class object 。

Class object 诞生管道
示例
运用 getClass()
注：每个 class 都有此函数
String str = "abc";
Class c1 = str.getClass();
运用
Class.getSuperclass() 2
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
运用 static method
Class.forName()
（最常被使用）
Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.LinkedList$Entry");
Class c4 = Class.forName ("I");
Class c5 = Class.forName ("[I");
运用
.class 语法
Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
运用
primitive wrapper classes
的 TYPE 语法
 
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;

图 1 ： Java 允许多种管道生成 Class object 。
 
以图 2 的 java.util.LinkedList 为例，将 Java class 的定义大卸八块，每一块分别对应图 3 所示的 Reflection API 。
 
package java.util;                 //(1)
import java.lang.*;                //(2)
public class LinkedList < E >              //(3)(4)(5)
extends AbstractSequentialList <E>               //(6)
implements List <E>, Queue <E>,
Cloneable, java.io.Serializable              //(7)
{
private static class Entry <E> { … }//(8)
public LinkedList () { … }                  //(9)
public LinkedList (Collection<? extends E> c) { … }
public E getFirst () { … }                  //(10)
public E getLast () { … }
private transient Entry<E> header = … ;        //(11)
private transient int size = 0;
}
图 2 ：将一个 Java class 大卸八块，每块相应于一个或一组 Reflection APIs （图 3 ）。
 
2.3    Java classes 各成份所对应的Reflection APIs
图 2 的各个 Java class 成份，分别对应于图 3 的 Reflection API ，其中出现的 Package 、 Method 、 Constructor 、 Field 等等 classes ，都定义于 java.lang.reflect 。本表并非 Reflection APIs 的全部。

Java class 内部模块（参见 图 3 ）
Java class 内部模块说明
相应之 Reflection API ，多半为 Class methods 。
返回值类型 (return type)
(1) package
class 隶属哪个 package
getPackage()
Package
(2) import
class 导入哪些 classes
无直接对应之 API 。
解决办法见 图 5-2 。
 
(3) modifier
class （或 methods, fields ）的属性
 
int getModifiers()
Modifier.toString(int)
Modifier.isInterface(int)
int
String
bool
(4) class name or interface name
class/interface
名称 getName()
String
(5) type parameters
参数化类型的名称
getTypeParameters()
TypeVariable <Class>[]
(6) base class
base class （只可能一个）
getSuperClass()
Class
(7) implemented interfaces
实现有哪些 interfaces
getInterfaces()
Class[]
 
(8) inner classes
内部 classes
getDeclaredClasses()
Class[]
(8') outer class
如果我们观察的 class 本身是 inner classes ，那么相对它就会有个 outer class 。
getDeclaringClass()
Class
(9) constructors
构造函数 getDeclaredConstructors()
不论 public 或 private 或其它 access level ，皆可获得。另有功能近似之取得函数。
Constructor[]
(10) methods
操作函数 getDeclaredMethods()
不论 public 或 private 或其它 access level ，皆可获得。另有功能近似之取得函数。
Method[]
(11) fields
字段（成员变量）
getDeclaredFields() 不论 public 或 private 或其它 access level ，皆可获得。另有功能近似之取得函数。
Field[]

图 3 ： Java class 大卸八块后（如图 2 ），每一块所对应的 Reflection API 。
Model.java
 
package RefInt;
 
import java.io.Serializable;
import java.util.Date;
 
public class Model implements Serializable {
 
    private static final long serialVersionUID = -162798607158235676L;
 
    public static String id = "111111" ;
    public String name = "haha" ;
    private int age ;
    private Date b ;
   
    public int getAge() {
       return age ;
    }
    public void setAge( int age) {
       this . age = age;
    }
    public Date getB() {
       return b ;
    }
    public void setB(Date b) {
       this . b = b;
    }
    public String getName() {
       return name ;
    }
    public void setName(String name) {
       this . name = name;
    }
}
RefInt.java
 
package RefInt;
 
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;
 
public class RefInt {
   
    public static void main(String[] args) {
       System. out .println( "f_1()" );
       f_1();
       System. out .println( "f_2()" );
       f_2();
       System. out .println( "f_3()" );
       f_3();
       System. out .println( "f_4()" );
       f_4();
       System. out .println( "getArrayByIndex()" );
       int [] a = {10,2,3,5};
       String[] s = { "aabc" , "aaabc" , "def" , "f" };
       // 数组排序
       Arrays.sort(s);
       System. out .println(getArrayByIndex(s,0));
       System. out .println(getArrayByIndex(a,0));
       System. out .println(getArrayByIndex(a,3));
       Arrays.sort(a);
       System. out .println(getArrayByIndex(a,0));
       System. out .println(getArrayByIndex(a,3));
       Array.set(a, 0, -1);
       System. out .println(getArrayByIndex(a,0));
    }
 
    /**
      * 获得数组 o 下标为 index 的值
      * @param o
      * @param index
      * @return
      */
    public static Object getArrayByIndex(Object o , int index) {
       return Array.get(o, index);
    }
   
    /**
      * 通过类名得到类描述对象
      * 通过类描述对象获得类模式（此类为 public ）
      */
    public static void f_4() {
       try {
           Class class_my = Class.forName( "RefInt.Model" );
           int m = class_my.getModifiers();
           System. out .println(class_my.getModifiers());
           if (Modifier.isPublic(m))
                System. out .println( "public" );
 
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       }
    }
   
    /**
      * 通过类名得到类描述对象
      * 通过类描述对象获得属性对象列表并显示其属性
      */
    public static void f_3() {
       try {
           Class class_my = Class.forName( "RefInt.Model" );
           // 只能得到属性是 public 的 Field
           Field[] publicFields = class_my.getFields();
           for ( int i = 0; i < publicFields. length ; i++) {
              String fieldName = publicFields[i].getName();
              Class typeClass = publicFields[i].getType();
              String fieldType = typeClass.getName();
              System. out .println( "Name: " + fieldName + ", Type: " + fieldType);
           }
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       }
    }
    /**
      * 通过实体对象获得类描述对象
      * 通过累描述对象获得指定属性对象
      * 通过属性对象实例得到属性名和属性值
      */
    public static void f_2() {
       Model model = new Model();
       // 属性必须是 public, 否则抛出 NoSuchFieldException 异常
       String sfiled = "name" ;
       Class class_my = model.getClass();
       try {
           Field filed = class_my.getField(sfiled);
           System. out .println(filed.getName());
           System. out .println(filed.get(model));
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (NoSuchFieldException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       }
    }
   
    /**
      * 通过类名获得实体对象
      * 通过属性名称获取实体对象属性值
      */
    public static void f_1() {
       try {
           Class cla = Class.forName( "RefInt.Model" );
           Object o = cla.newInstance();
           String methodName = "getName" ;
           Method m = cla.getMethod(methodName, (Class[]) null );
           System. out .println(m.invoke(o, (Object[]) null ));
           methodName = "getAge" ;
           m = cla.getMethod(methodName, (Class[]) null );
           System. out .println(m.invoke(o, (Object[]) null ));
           methodName = "getB" ;
           m = cla.getMethod(methodName, (Class[]) null );
           System. out .println(m.invoke(o, (Object[]) null ));
       } catch (ClassNotFoundException e) {
           e.printStackTrace();
       } catch (InstantiationException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (SecurityException e) {
           e.printStackTrace();
       } catch (NoSuchMethodException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       } catch (InvocationTargetException e) {
           e.printStackTrace();
       }
    }
}
 
一般的做法是通过类 Introspector 来获取某个对象的 BeanInfo 信息，然后通过 BeanInfo 来获取属性的描述器（ PropertyDescriptor ），通过这个属性描述器就可以获取某个属性对应的 getter/setter 方法，然后我们就可以通过反射机制来调用这些方法。
Intro.java
 
package RefInt;
 
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
 
public class Intro {
    public static void main(String[] args) {
       Model m = new Model();
       try {
           // 从其所在位置开始停止分析的基类。 stopClass 或其基类中的所有方法 / 属性 / 事件都将在分析中被忽略。
           BeanInfo beanInfor = Introspector.getBeanInfo(m.getClass(),Object. class );
           PropertyDescriptor[] p = beanInfor.getPropertyDescriptors();
           for ( int i=0;i<p. length ;i++){
              System. out .println(p[i].getName()+ "=" +
                      p[i].getReadMethod().invoke(m,(Object[]) null ));
            }
 
       } catch (IntrospectionException e) {
           e.printStackTrace();
       } catch (IllegalArgumentException e) {
           e.printStackTrace();
       } catch (IllegalAccessException e) {
           e.printStackTrace();
       } catch (InvocationTargetException e) {
           e.printStackTrace();
       }
    }
}
 
xxdyynn163
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java的自省机制_深入理解Java反射机制
weixin_35006125的博客
03-02 1011
前言最近在接触 Android 的组件化原理的时候，发现自己对 Java 反射的机制理解并不是很深，只能利用周末的时间把 Java 反射机制回炉重铸。什么是Java反射反射机制是 Java 语言提供的一种基础功能，赋予了 Java 程序在运行时的自省(introspect，官方用语)的能力。通过 Java 的反射机制，程序员可以在 Java 程序在运行态的时候操作任意的类或者对象的属性、方法。利用...
Java反射与内省-PPT
11-20
Java反射与内省是Java编程语言中的核心特性，它们为开发者提供了强大的能力，可以在运行时检查和操作类、接口、对象及其属性。本PPT深入探讨了这些概念，旨在帮助开发者充分利用Java平台的灵活性。 首先，Java反射...
java语言自省------反射
u010214269的专栏
11-23 1202
第一次去接触反射，感觉很陌生，接触一点后
JAVA的内省机制（introspector）与反射机制（reflection）
zgmzyr的专栏
07-21 7121
 <br />相对而言，反射比内省更容易理解一点。用一句比较白的话来概括，反射就是让你可以通过名称来得到对象 ( 类，属性，方法 ) 的技术，这种技术比内省机制使用范围更广泛。例如我们可以通过类名来生成一个类的实例；知道了方法名，就可以调用这个方法；知道了属性名就可以访问这个属性的值。 内省是 Java 语言对 Bean 类属性、事件的一种缺省处理方法。例如类 A 中有属性 name, 那我们可以通过 getName,setName 来得到其值或者设置新的值。通过 getName/setName 来访问 n
java的反射和内省机制
09-27 2012
前几天看一本提到了JAVA的反射机制,由于过于概念不能很好理解.没想到在网络编程中又碰到了这个问题.看来不能回避了,要好好去学习一下了.反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来
Java中的反射和内省简单实例
在风雨中奔跑
05-22 539
1.反射和内省          反射式在运行状态把Java类中的各种成分映射成相应的Java类，可以动态的获取所有的属性以及动态调用任意一个方法，强调的是运行状态。       内省机制是通过反射来实现的，BeanInfo用来暴露一个bean的属性、方法和事件，以后我们就可以操纵该JavaBean的属性。 2.反射和内省的图 一个简
java反射全解（反射原理+反射API详解+反射与数组+反射与泛型+反射源码与性能开销+反射优缺点+反射与内省）
06-21
java 反射机制是 Java 语言中的一种动态获取信息和调用对象方法的技术核心。它允许在程序运行时加载、探索以及使用编译期间完全未知的 .class 文件。通过反射机制，可以在运行时判断任意一个对象所属的类、构造任意...
Java 内省(Introspector)深入理解
08-31
Java内省（Introspector）是Java语言提供的一种机制，用于在运行时分析Java对象的属性、方法和事件。这个特性对于开发人员来说非常有用，因为它允许程序动态地检查和修改对象的状态，而不必了解对象的具体实现细节。...
minimalcode-reflect:JavaBean 的简约反射和内省功能
05-30
在Java编程语言中，反射和内省是两个强大的特性，它们允许程序在运行时检查类、接口、字段和方法的信息，甚至动态地调用方法和访问属性。"minimalcode-reflect"项目提供了一个简约的框架，专注于JavaBean的反射和...
Java中的内省与反射.doc
最新发布
06-28
Java中的内省与反射
Java自省类教程
09-09
reflection 是一系列的ＡＰＩ，它用于表示或者处理当前ＪＶＭ中的类，接口和对象。
Java 自省类教程.rar
07-13
Java 自省类教程
java 反射与内省
qq_45809896的博客
08-25 89
什么叫反射？ JAVA 反射机制是在运行状态中 ， 对于任意一个类 ， 都能够知道这个类的所有属性和方法 ； 对于任意一个对象 ， 都能够调 用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。 认识 Class 类 Class 类表示什么？ 很多的人——可以定义一个 Person 类（有年龄，性别，姓名等） 很多的车——可以定义一个 Car 类（有发动机，颜色，车轮等） 很多的类——Class 类 此类是一个最终类，是不允许有子类的，而且此类声明的时候使
Java学习笔记——反射机制
m0_53127728的博客
04-30 640
在编译时，当我们无法得知该对象或类可能属于哪些类，可以使用反射动态获取该对象或者类的信息。
Java反射和内省机制的区别
Jet_Green的博客
08-06 814
很多人了解Java发射机制，但是今天我在学习springIOC（依赖注入）的原理的时候，注意到了一个词叫做内省机制 那么我就在想这个内省机制是什么呢？ WiKi上的解释是： 在计算机科学中，内省是指计算机程序在运行时（Run time）检查对象（Object）类型的一种能力， 通常也可以称作运行时类型检查。 不应该将内省和反射混淆。 相对于内省，反射更进一步， 是指计算机程序在运行时（...
Java的反射机制 —— 类的镜子
莪是男神的博客
07-17 565
定义在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java语言的反射（Reflection）机制。反射（Reflection）是Java语言的特性之一，能够让Java程序在运行时动态地执行类的方法、构造方法等。可以说有了反射，不管什么类在我们面前都毫无隐私可言，什么private、protected、defaultPerl、Python、Ruby是动态语言，而C++...
JAVA 反射方法总结
m0_50210478的博客
01-22 288
反射方法总结
java的自省机制_JAVA内省(自省)机制 ( Introspector , BeanInfo, PropertyDescriptor )
weixin_42131601的博客
03-02 693
目的和作用： 通过内省，获取和操作javaBean中的成员信息(方法，事件，属性)。—————————————————-内省使用的核心类(接口)———————————————————–Java.beans.Introspector –工具类，通过 Introspector 类就可以获取和操作javaBean中的属性、事件和方法。(staticBeanInfo)getBeanInfo(Class...
java 自省机制_Java自省机制 - 哈全文的博文 - OSCHINA - 中文开源技术交流社区
weixin_34911236的博客
02-13 158
JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露称为属性。众所周知，属性名称符合这种模式，其他Java 类可以通过自省机制发现和操作这些JavaBean 属性。对于自省机制，举例如下：HTML中内容(注意红色部分)：登录帐号：登录密码：JSP中内容：&lt...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值