当前位置：文档库 › Java反射机制

Java反射机制

Java学习之二-Java反射机制

问题：

在运行时，对一个JA V A类，能否知道属性和方法；能否调用它的任意方法？

答案是可以的，JA V A提供一种反射机制可以实现。

1什么是JA V A的反射机制

2JDK中提供的Reflection API

3JA V A反射机制提供了什么功能

o获取类的Class对象

o获取类的Fields

o获取类的Method

o获取类的Constructor

o新建类的实例

Class的函数newInstance

通过Constructor对象的方法newInstance

4调用类的函数

调用private函数

5设置/获取类的属性值

private属性

6动态创建代理类

动态代理源码分析

7JA V A反射Class类型源代码分析

8JA V A反射原理分析

Class文件结构

JVM加载类对象，对反射的支持

9JA V A反射的应用

一、什么是JAV A的反射机制

Java反射是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等）、superclass（例如Object）、实现之interfaces（例如Cloneable），也包括fields 和methods的所有信息，并可于运行时改变fields内容或唤起methods。

Java反射机制容许程序在运行时加载、探知、使用编译期间完全未知的classes。

换言之，Java可以加载一个运行时才得知名称的class，获得其完整结构。

二、JDK中提供的Reflection API

Java反射相关的API在包https://www.wendangku.net/doc/ed11198216.html,ng.reflect中，JDK 1.6.0的reflect包如下图：

Member接口该接口可以获取有关类成员（域或者方法）后者构造函数的信息。

AccessibleOb ject类该类是域(field)对象、方法(method)对象、构造函数(constructor)对象的基础类。它提供了将反射的对象标记为在使用时取消默认Java 语言访问控制检查的能力。

Array类该类提供动态地生成和访问JA V A数组的方法。

Constructor

类

提供一个类的构造函数的信息以及访问类的构造函数的接口。

Field类提供一个类的域的信息以及访问类的域的接口。

Method类提供一个类的方法的信息以及访问类的方法的接口。

Modifier类提供了static 方法和常量，对类和成员访问修饰符进行解码。

Proxy类提供动态地生成代理类和类实例的静态方法。

三、JAV A反射机制提供了什么功能

Java反射机制提供如下功能：

在运行时判断任意一个对象所属的类

在运行时构造任意一个类的对象

在运行时判段任意一个类所具有的成员变量和方法

在运行时调用任一个对象的方法

在运行时创建新类对象

在使用Java的反射功能时，基本首先都要获取类的Class对象，再通过Class对象获取其他的对象。

这里首先定义用于测试的类: View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 classType{

publicintpubIntField;

publicString pubStringField;

privateintprvIntField;

publicType(){

Log("Default Constructor");

}

Type(intarg1, String arg2){

pubIntField = arg1;

pubStringField = arg2;

Log("Constructor with parameters");

}

publicvoidsetIntField(intval) {

this.prvIntField = val;

}

publicintgetIntField() {

returnprvIntField;

}

privatevoidLog(String msg){

System.out.println("Type:"+ msg);

}

classExtendTypeextendsType{

publicintpubIntExtendField;

publicString pubStringExtendField;

32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 privateintprvIntExtendField;

publicExtendType(){

Log("Default Constructor");

}

ExtendType(intarg1, String arg2){

pubIntExtendField = arg1;

pubStringExtendField = arg2;

Log("Constructor with parameters");

}

publicvoidsetIntExtendField(intfield7) {

this.prvIntExtendField = field7;

}

publicintgetIntExtendField() {

returnprvIntExtendField;

}

privatevoidLog(String msg){

System.out.println("ExtendType:"+ msg);

}

1、获取类的Class 对象

Class 类的实例表示正在运行的 Java 应用程序中的类和接口。获取类的Class 对象有多种方式：

调用getClass Boolean var1 = true;

Class classType2 = var1.getClass();

System.out.println(classType2);

输出：class https://www.wendangku.net/doc/ed11198216.html,ng.Boolean

运用.class 语法Class classType4 = Boolean.class;

System.out.println(classType4);

输出：class https://www.wendangku.net/doc/ed11198216.html,ng.Boolean

运用static method Class.forName() Class classType5 = Class.forName("https://www.wendangku.net/doc/ed11198216.html,ng.Boolean"); System.out.println(classType5);

输出：class https://www.wendangku.net/doc/ed11198216.html,ng.Boolean

运用primitive wrapper classes 的TYPE 语法这里返回的是原生类型，和Boolean.class返回的不同Class classType3 = Boolean.TYPE; System.out.println(classType3);

输出：boolean

2、获取类的Fields

可以通过反射机制得到某个类的某个属性，然后改变对应于这个类的某个实例的该属性值。JA V A 的Class类提供了几个方法获取类的属性。

public Field getField(String name) 返回一个Field 对象，它反映此Class 对象所表示的类或接口的指定公共成员字段

public Field[] getFields() 返回一个包含某些Field 对象的数组，这些对象反映此Class 对象所表示的类或接口的所有可访问公共字段

public Field getDeclaredField (String name) 返回一个Field 对象，该对象反映此Class 对象所表示的类或接口的指定已声明字段

public Field[] getDeclaredField s() 返回Field 对象的一个数组，这些对象反映此Class 对象所表示的类或接口所声明的所有字段

View Code?

1 2 3 4 5 6 7 Class classType = ExtendType.class;

// 使用getFields获取属性

Field[] fields = classType.getFields(); for(Field f : fields)

{

System.out.println(f);

8 9 10 11 12 13 14 15 16 17 }

System.out.println();

// 使用getDeclaredFields 获取属性

fields = classType.getDeclaredFields();

for(Field f : fields)

{

System.out.println(f);

}

输出：

public int com.quincy.ExtendType.pubIntExtendField

public https://www.wendangku.net/doc/ed11198216.html,ng.String com.quincy.ExtendType.pubStringExtendField

public int com.quincy.Type.pubIntField

public https://www.wendangku.net/doc/ed11198216.html,ng.String com.quincy.Type.pubStringField

public int com.quincy.ExtendType.pubIntExtendField

public https://www.wendangku.net/doc/ed11198216.html,ng.String com.quincy.ExtendType.pubStringExtendField

private int com.quincy.ExtendType.prvIntExtendField

可见getFields 和getDeclaredFields 区别：

getFields 返回的是申明为public 的属性，包括父类中定义，

getDeclaredFields 返回的是指定类定义的所有定义的属性，不包括父类的。

3、获取类的Method

通过反射机制得到某个类的某个方法，然后调用对应于这个类的某个实例的该方法 Class类提供了几个方法获取类的方法。

public Method getMethod(String name, Class ...

parameterTypes)

返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法

public Method [] getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些

的类或接口）的公共 member 方法

public Method getDeclaredMeth

返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定

od(String name,Class ...

parameterTypes)

已声明方法

public Method [] getDeclaredMeth ods() 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法 View Code?

9 10 11 12 13 14 15 16 // 使用getMethods 获取函数 Class classType = ExtendType.class; Method[] methods = classType.getMethods(); for(Method m : methods) { System.out.println(m); } System.out.println();

// 使用getDeclaredMethods 获取函数 methods = classType.getDeclaredMethods(); for(Method m : methods) { System.out.println(m); }

输出：

public void com.quincy.ExtendType.setIntExtendField(int)

public int com.quincy.ExtendType.getIntExtendField()

public void com.quincy.Type.setIntField(int)

public int com.quincy.Type.getIntField()

public final native void https://www.wendangku.net/doc/ed11198216.html,ng.Object.wait(long) throws https://www.wendangku.net/doc/ed11198216.html,ng.InterruptedException public final void https://www.wendangku.net/doc/ed11198216.html,ng.Object.wait() throws https://www.wendangku.net/doc/ed11198216.html,ng.InterruptedException

public final void https://www.wendangku.net/doc/ed11198216.html,ng.Object.wait(long,int) throws https://www.wendangku.net/doc/ed11198216.html,ng.InterruptedException public boolean https://www.wendangku.net/doc/ed11198216.html,ng.Object.equals(https://www.wendangku.net/doc/ed11198216.html,ng.Object)

public https://www.wendangku.net/doc/ed11198216.html,ng.String https://www.wendangku.net/doc/ed11198216.html,ng.Object.toString()

public native int https://www.wendangku.net/doc/ed11198216.html,ng.Object.hashCode()

public final native https://www.wendangku.net/doc/ed11198216.html,ng.Class https://www.wendangku.net/doc/ed11198216.html,ng.Object.getClass()

public final native void https://www.wendangku.net/doc/ed11198216.html,ng.Object.notify()

public final native void https://www.wendangku.net/doc/ed11198216.html,ng.Object.notifyAll()

private void com.quincy.ExtendType.Log(https://www.wendangku.net/doc/ed11198216.html,ng.String)

public void com.quincy.ExtendType.setIntExtendField(int)

public int com.quincy.ExtendType.getIntExtendField()

4、获取类的Constructor

通过反射机制得到某个类的构造器，然后调用该构造器创建该类的一个实例Class类提供了几个方法获取类的构造器。

public Constructor getConstructor(Cl ass... parameterTypes) 返回一个Constructor 对象，它反映此Class 对象所表示的类的指定公共构造方法

public Constructor[] getConstructors() 返回一个包含某些Constructor 对象的数组，这些对象反映此Class 对象所表示的类的所有公共构造方法

public Constructor getDeclaredConstr uctor(Class... parameterTypes) 返回一个Constructor 对象，该对象反映此Class 对象所表示的类或接口的指定构造方法

public Constructor[] getDeclaredConstr uctors() 返回Constructor 对象的一个数组，这些对象反映此Class 对象表示的类声明的所有构造方法。它们是公共、保护、默认（包）访问和私有构造方法

View Code?

1 2 3 4 5 6 7 8 // 使用getConstructors获取构造器

Constructor[] constructors = classType.getConstructors(); for(Constructor m : constructors)

{

System.out.println(m);

}

System.out.println();

9 10 11 12 13 14 15 16 17 18 19 20 21

// 使用getDeclaredConstructors 获取构造器

constructors = classType.getDeclaredConstructors();

for(Constructor m : constructors)

{

System.out.println(m);

}

输出：

publiccom.quincy.ExtendType()

com.quincy.ExtendType(int,https://www.wendangku.net/doc/ed11198216.html,ng.String)

5、新建类的实例

通过反射机制创建新类的实例，有几种方法可以创建

调用无自变量ctor 1、调用类的Class 对象的newInstance 方法，该方法会调用对象的默认构造器，如果没有默认构造器，会调用失败.

Class classType = ExtendType.class;

Object inst = classType.newInstance();

System.out.println(inst);

输出：

Type:Default Constructor

ExtendType:Default Constructor com.quincy.ExtendType@d80be3

2、调用默认Constructor 对象的newInstance 方法

Class classType = ExtendType.class;

Constructor constructor1 = classType.getConstructor();

Object inst = constructor1.newInstance();

System.out.println(inst);

输出：

Type:Default Constructor

ExtendType:Default Constructor

com.quincy.ExtendType@1006d75

调用带参数ctor 3、调用带参数Constructor 对象的newInstance 方法

Constructor constructor2 =

classType.getDeclaredConstructor(int.class, String.class);

Object inst = constructor2.newInstance(1, "123");

System.out.println(inst);

输出：

Type:Default Constructor

ExtendType:Constructor with parameters

com.quincy.ExtendType@15e83f9

6、调用类的函数

通过反射获取类Method 对象，调用Field 的Invoke 方法调用函数。 View Code?

9 10 11 12 13 14 15 16 Class classType = ExtendType.class;

Object inst = classType.newInstance();

Method logMethod = classType.getDeclaredMethod("Log", String.class); logMethod.invoke(inst,"test"); 输出： Type:Default Constructor ExtendType:Default Constructor Class com.quincy.ClassT can not access a member

ofclasscom.quincy.ExtendType with modifiers"private" 上面失败是由于没有权限调用private 函数，这里需要设置Accessible 为true; Class classType = ExtendType.class; Object inst = classType.newInstance(); Method logMethod = classType.getDeclaredMethod("Log", String.class);

logMethod.setAccessible(true); logMethod.invoke(inst,"test");

7、设置/获取类的属性值

通过反射获取类的Field 对象，调用Field 方法设置或获取值 View Code?

1 2 3 4 5 Class classType = ExtendType.class; Object inst = classType.newInstance(); Field intField = classType.getField("pubIntExtendField"); intField.setInt(inst,100); intvalue = intField.getInt(inst); View Code?

四、动态创建代理类

代理模式：代理模式的作用=为其他对象提供一种代理以控制对这个对象的访问。代理模式的角色：

抽象角色：声明真实对象和代理对象的共同接口

代理角色：代理角色内部包含有真实对象的引用，从而可以操作真实对象。

真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。

动态代理：

https://www.wendangku.net/doc/ed11198216.html,ng.reflect.P roxy Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类

InvocationHandle r 是代理实例的调用处理程序实现的接口，每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到

它的调用处理程序的 invoke 方法。

动态Proxy 是这样的一种类:

它是在运行生成的类，在生成时你必须提供一组Interface 给它，然后该class 就宣称它实现了这些interface 。你可以把该class 的实例当作这些interface 中的任何一个来用。当然，这个Dynamic Proxy 其实就是一个Proxy ，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler ，由它接管实际的工作。

在使用动态代理类时，我们必须实现InvocationHandler 接口

步骤：

1、定义抽象角色

public interface Subject {

public void Request();

}

2、定义真实角色

public class RealSubject implements Subject {

@Override

public void Request() {

// TODO Auto-generated method stub

System.out.println("RealSubject");

}

3、定义代理角色

public class DynamicSubject implements InvocationHandler {

private Object sub;

public DynamicSubject(Object obj){

this.sub = obj;

}

@Override

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

// TODO Auto-generated method stub

System.out.println("Method:"+ method + ",Args:" + args);

method.invoke(sub, args);

return null;

}

4、通过Proxy.newProxyInstance构建代理对象

RealSubject realSub = new RealSubject();

InvocationHandler handler = new DynamicSubject(realSub);

Class classType = handler.getClass();

Subject sub = (Subject)Proxy.newProxyInstance(classType.getClassLoader(), realSub.getClass().getInterfaces(), handler);

System.out.println(sub.getClass());

5、通过调用代理对象的方法去调用真实角色的方法。

sub.Request();

输出：

class $Proxy0 新建的代理对象，它实现指定的接口

Method:public abstract void DynamicProxy.Subject.Request(),Args:null RealSubject 调用的真实对象的方法

待续...

JAVA反射机制(内含大量实例)

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实

际状态和行为上的情况，反之亦然。开放性和原因连接是反射系统的两大基本要素。 Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。二、Java中的类反射： Reflection 是 Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 1．检测类： 1.1 reflection的工作机制考虑下面这个简单的例子，让我们看看 reflection 是如何工作的。

java反射机制

Java的反射机制是Java特性之一，反射机制是构建框架技术的基础所在。灵活掌握Java反射机制，对大家以后学习框架技术有很大的帮助。那么什么是Java的反射呢？大家都知道，要让Java程序能够运行，那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载，是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。 Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。那么Java反射有什么作用呢？假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。 Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。 Class类要正确使用Java反射机制就得使用https://www.wendangku.net/doc/ed11198216.html,ng.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。反射API ◆反射API用于反应在当前Java虚拟机中的类、接口或者对象信息 ◆功能 —获取一个对象的类信息. —获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息. —检获属于一个接口的常量和方法声明. —创建一个直到程序运行期间才知道名字的类的实例. —获取并设置一个对象的成员，甚至这个成员的名字是在程序运行期间才知道. —检测一个在运行期间才知道名字的对象的方法利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信

JAVA的反射机制与动态代理

JA V A的反射机制与动态代理李海峰（QQ:61673110）-Andrew830314@https://www.wendangku.net/doc/ed11198216.html, 运行时类型信息（RunTime Type Information，RTTI）使得你在程序运行时发现和使用类型信息。RTTI主要用来运行时获取向上转型之后的对象到底是什么具体的类型。 1.Class对象： JAVA使用Class对象来执行RTTI。每个类都有一个Class对象，它用来创建这个类的所有对象，反过来说，每个类的所有对象都会关联同一个Class对象（对于数组来说，维数、类型一致的数组的Class对象才是相同的），每个对象的创建都依赖于Class对象的是否创建，Class对象的创建发生在类加载（https://www.wendangku.net/doc/ed11198216.html,ng.ClassLoader）的时候。 https://www.wendangku.net/doc/ed11198216.html,ng.Class类实现了Serializable、GenericDeclaration、Type、AnnotatedElement四个接口，分别实现了可序列化、泛型定义、类型、元数据（注解）的功能。你可以把Class对象理解为一个类在内存中的接口代理（它代理了这个类的类型信息、方法签名、属性），JVM加载一个类的时候首先创建Class对象，然后创建这个类的每个实例的时候都使用这个Class对象。 Class只有一个私有的无参构造方法，也就是说Class的对象创建只有JVM可以完成。如何验证同一个类的多个对象的Class对象是一个呢？ Cf1 cf1 = new Cf1(); Class clazz = Cf1.class; System.out.println(cf1.getClass() == clazz); 我们知道==用来比较引用是否相等（也就是同一个引用），上面的输出语句结果是true。那么Class对象是否相等是JAVA对象中唯一可以使用==判断的。如何获取Class对象： 1.所有的引用数据类型（类-类型）的类名、基本数据类型都可以通过.class方式获取其Class 对象（对于基本数据类型的封装类还可以通过.TYPE的方式获取其Class对象，但要注意.TYPE实际上获取的封装类对应的基本类型的Class对象的引用，那么你可以判断出int.class==Integer.TYPE返回true，int.class==Integer.class返回false！），通过这种方式不会初始化静态域，使用.class、.TYPE的方式获取Class对象叫做类的字面常量； 2.Class的forName(String name)传入一个类的完整类路径也可以获得Class对象，但由于使用的是字符串，必须强制转换才可以获取泛型的Class的Class对象，并且你必须获取这个方法可能抛出的ClassNotFoundException异常。 2.对于引用数据类的引用（必须初始化），可以通过Object类继承的getClass()方法获取这个引用的Class对象，由于引用已经被初始化，所以这种方式也不会初始化静态域，因为静态域已经被初始化过。另外，前面两种方式如果说是创建Class对象，那么这种方式应该是取得Class对象，因为类的实例已经被创建，那么Class对象也一定早就被创建。 Class的常用方法： l forName(String name)：这是一个静态方法，传入的参数是一个类的完整类路径的字符串，返回这个类的Class对象，前面说过Class对象的创建发生在类的加载时，所以这个方法会导致静态成员被调用； l forName(String name,boolean initialize,ClassLoader loader)：这是上面的方

JAVA中的反射机制

JAVA中的反射机制一，先看一下反射的概念：主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。反射是java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。但是反射使用不当会成本很高！看概念很晕的，继续往下看。二，反射机制的作用： 1，反编译：.class-->.java 2,通过反射机制访问java对象的属性，方法，构造方法等；这样好像更容易理解一些，下边我们具体看怎么实现这些功能。三，在这里先看一下sun为我们提供了那些反射机制中的类： https://www.wendangku.net/doc/ed11198216.html,ng.Class; https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Constructor; https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Field; https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Method; https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Modifier; 很多反射中的方法，属性等操作我们可以从这四个类中查询。还是哪句话要学着不断的查询API，那才是我们最好的老师。四，具体功能实现：

1，反射机制获取类有三种方法，我们来获取Employee类型 [java]view plain copy print? 1.//第一种方式： 2.Class c1 = Class.forName("Employee"); 3.//第二种方式： 4.//java中每个类型都有class 属性. 5.Class c2 = Employee.class; 6. 7.//第三种方式： 8.//java语言中任何一个java对象都有getClass 方法 9.Employee e = new Employee(); 10.Class c3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) 2，创建对象：获取类以后我们来创建它的对象，利用newInstance： 1.Class c =Class.forName("Employee"); 2. 3.//创建此Class 对象所表示的类的一个新实例 4.Objecto = c.newInstance(); //调用了Employee的无参数构造方法. 3,获取属性：分为所有的属性和指定的属性： a，先看获取所有的属性的写法： 1.//获取整个类 2. Class c = Class.forName("https://www.wendangku.net/doc/ed11198216.html,ng.Integer"); 3.//获取所有的属性? 4. Field[] fs = c.getDeclaredFields(); 5. 6.//定义可变长的字符串，用来存储属性 7. StringBuffer sb = new StringBuffer(); 8.//通过追加的方法，将每个属性拼接到此字符串中 9.//最外边的public定义 10. sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n"); 11.//里边的每一个属性 12.for(Field field:fs){ 13. sb.append("\t");//空格 14. sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符，例如 public，static等等 15. sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字 16. sb.append(field.getName()+";\n");//属性的名字+回车

一个例子让你了解Java反射机制

一个例子让你了解Java反射机制 JAVA反射机制：通俗地说,反射机制就是可以把一个类,类的成员(函数,属性),当成一个对象来操作,希望读者能理解,也就是说,类,类的成员,我们在运行的时候还可以动态地去操作他们. 理论的东东太多也没用，下面我们看看实践 Demo ～ Demo: 1.package cn.lee.demo; 2. 3.import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Constructor; 4.import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Field; 5.import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.InvocationTargetException; 6.import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Method; 7.import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Modifier; 8.import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.TypeVariable; 9. 10.public class Main { 11. /** 12. * 为了看清楚Java反射部分代码，所有异常我都最后抛出来给虚拟机处理！ 13. * @param args 14. * @throws ClassNotFoundException 15. * @throws InstantiationException 16. * @throws IllegalAccessException 17. * @throws InvocationTargetException 18. * @throws IllegalArgumentException 19. * @throws NoSuchFieldException 20. * @throws SecurityException 21. * @throws NoSuchMethodException 22. */

深入理解Java反射机制汇总

深入理解Java反射机制本文较为详细的分析了Java反射机制。分享给大家供大家参考，具体如下：一、预先需要掌握的知识(java虚拟机) java虚拟机的方法区: java虚拟机有一个运行时数据区，这个数据区又被分为方法区，堆区和栈区，我们这里需要了解的主要是方法区。方法区的主要作用是存储被装载的类的类型信息，当java虚拟机装载某个类型的时候，需要类装载器定位相应的class文件，然后将其读入到java虚拟机中，紧接着虚拟机提取class 中的类型信息，将这些信息存储到方法区中。这些信息主要包括: 1、这个类型的全限定名 2、这个类型的直接超类的全限定名 3、这个类型是类类型还是接口类型 4、这个类型的访问修饰符 5、任何直接超接口的全限定名的有序列表 6、该类型的常量池 7、字段信息 8、方法信息 9、除了常量以外的所有类变量 10、一个到class类的引用等等(读者可以参考《深入java虚拟机》这本书的叙述) Class类: Class类是一个非常重要的java基础类，每当装载一个新的类型的时候，java虚拟机都会在java堆中创建一个对应于新类型的Class实例，该实例就代表此类型，通过该Class实例我们就可以访问该类型的基本信息。上面说到在方法区中会存储某个被装载类的类型信息，我们就可以通过Class实例来访问这些信息。比如，对于上面说到的信息Class中都有对应的方法，如下:

1、getName()；这个类型的全限定名 2、getSuperClass()；这个类型的直接超类的全限定名 3、isInterface()；这个类型是类类型还是接口类型 4、getTypeParamters()；这个类型的访问修饰符 5、getInterfaces()；任何直接超接口的全限定名的有序列表 6、getFields()；字段信息 7、getMethods()；方法信息等等(读者可以自己参看jdk帮助文档，得到更多的信息) 二、java反射详解反射的概念:所谓的反射就是java语言在运行时拥有一项自观的能力，反射使您的程序代码能够得到装载到JVM中的类的内部信息，允许您执行程序时才得到需要类的内部信息，而不是在编写代码的时候就必须要知道所需类的内部信息，这使反射成为构建灵活的应用的主要工具。反射的常用类和函数:Java反射机制的实现要借助于4个类：Class，Constructor，Field，Method；其中class代表的是类对象，Constructor－类的构造器对象，Field－类的属性对象，Method －类的方法对象，通过这四个对象我们可以粗略的看到一个类的各个组成部分。其中最核心的就是Class类，它是实现反射的基础，它包含的方法我们在第一部分已经进行了基本的阐述。应用反射时我们最关心的一般是一个类的构造器、属性和方法，下面我们主要介绍Class 类中针对这三个元素的方法: 1、得到构造器的方法 Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数，Constructor[] getConstructors() -- 获得类的所有公共构造函数 Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关) Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 2、获得字段信息的方法

JAVA反射机制之Class类API实例介绍 - AJava

JAVA反射机制之Class类API实例介绍- AJava JAVA反射机制之Class类API实例介绍核心提示：本文针对jdk6.0中https://www.wendangku.net/doc/ed11198216.html,ng.Class类的API进行了简单的实例应用，例子简单易懂，比较适合入门级阅读。实例简介：/* *IncludeInnerClass类中包含了三种访问控制的内部类，并且以这三个内部类的引用对象和一个整型数作为属性，在外部类的方法中分别调用了内部本文针对jdk6.0中https://www.wendangku.net/doc/ed11198216.html,ng.Class类的API进行了简单的实例应用，例子简单易懂，比较适合入门级阅读。实例简介：/* *IncludeInnerClass类中包含了三种访问控制的内部类，并且以这三个内部类的引用对象和一个整型数作为属性，在外部类的方法中分别调用了内部类的方法 *外部类有两个构造方法，一个默认构造方法，一个带一个整型参数的构造方法 *Class类的API大家可以直接查阅jdk手册

*getMethods()系列方法基本与getConstructors()系列方法类似，仅在后序文章中对getMethods()系列方法的一个特例做深入介绍，将涉及covariant return type 和bridge methods。 */ package classTest; import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Field; import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Modifier; import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Constructor; import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Method; class IncludeInnerClass implements Runnable{ class DefaultInnerClass{ int i; public DefaultInnerClass(){} DefaultInnerClass(int i){ this.i = i; } void innerMethod(){

Java中类反射机制基本原理

Java中的类反射机制一、反射的概念反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。其中LEAD/LEAD++ 、Open C++ 、Meta Xa和Open Java等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。反射本身并不是一个新概念，它可能会使我们联想到光学中的反射概念，尽管计算机科学赋予了反射概念新的含义，但是，从现象上来说，它们确实有某些相通之处，这些有助于我们的理解。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。可以看出，同一般的反射概念相比，计算机科学领域的反射不单单指反射本身，还包括对反射结果所采取的措施。所有采用反射机制的系统（即反射系统）都希望使系统的实现更开放。可以说，实现了反射机制的系统都具有开放性，但具有开放性的系统并不一定采用了反射机制，开放性是反射系统的必要条件。一般来说，反射系统除了满足开放性条件外还必须满足原因连接（Causally-connected）。所谓原因连接是指对反射系统自描述的改变能够立即反映到系统底层的实际状态和行为上的情况，反之亦然。开放性和原因连接是反射系统的两大基本要素。 Java中，反射是一种强大的工具。它使您能够创建灵活的代码，这些代码可以在运行时装配，无需在组件之间进行源代表链接。反射允许我们在编写与执行时，使我们的程序代码能够接入装载到JVM中的类的内部信息，而不是源代码中选定的类协作的代码。这使反射成为构建灵活的应用的主要工具。但需注意的是：如果使用不当，反射的成本很高。二、Java类反射 Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者C++ 中就没有办法在程序中获得函数定义相关的信息。 1．检测类 1.1 reflection的工作机制考虑下面这个简单的例子，让我们看看reflection 是如何工作的。 import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.*; public class DumpMethods { public static void main(String args[]) { try { Class c = Class.forName(args[0]); Method m[] = c.getDeclaredMethods(); for (int i = 0; i < m.length; i++) System.out.println(m[i].toString()); } catch (Throwable e) { System.err.println(e); }

JAVA的类反射机制

JAVA的类反射机制一、什么是反射：反射的概念是由Smith 在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp 和面向对象方面取得了成绩。其中LEAD/LEAD++ 、OpenC++ 、MetaXa 和 OpenJava 等就是基于反射机制的语言。最近，反射机制也被应用到了视窗系统、操作系统和文件系统中。反射本身并不是一个新概念，尽管计算机科学赋予了反射概念新的含义。在计算机科学领域，反射是指一类应用，它们能够自描述和自控制。也就是说，这类应用通过采用某种机制来实现对自己行为的描述（self-representation）和监测（examination），并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。二、什么是Java 中的类反射： Reflection 是Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。Java 的这一能力在实际应用中用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。 Reflection 是Java 被视为动态（或准动态）语言的关键，允许程序于执行期Reflection APIs 取得任何已知名称之class 的內部信息，包括package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可于执行期生成instances、变更fields 內容或唤起methods。三、Java 类反射中所必须的类： Java 的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object，下面我将对这些类做一个简单的说明。 Field 类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。

java反射机制详解与应用

java有着一个非常突出的动态相关机制：Reflection。这个字的意思是“反射、映象、倒影”，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods1。这种“看透class”的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces （例如Cloneable），也包括fields和methods的所有信息，并可于运行时改变fields内容或唤起methods。目前好多框架都会用到java的反射机制。比如struts2,sping,hibernate。如果我们不用struts2，自己写一个类似的功能也是可以实现的，比如浏览器通过HTTP发送数据，而这些数据都是字符串，我们接受到这些字符串时，可以通过反射去构造一个对象(通过拦截器做成框架的功能)，这样就可以用对象的get和set方法了，而不用原始的getPeremter 方法。事实上，在struts2出来之前，我们又不想用struts1的ActionForm就做过这样项目。一、Class object 的产生方式有以下几种。 1、运用getClass() 注：每个class 都有此函数 String str = "abc"; Class c1 = str.getClass(); 2、运用static method Class.forName()（最常被使用） Class c1 = Class.forName ("https://www.wendangku.net/doc/ed11198216.html,ng.String"); Class c2 = Class.forName ("java.awt.Button"); 3、运用.class 语法 Class c1 = String.class; Class c2 = java.awt.Button.class; 4、运用primitive wrapper classes的TYPE 语法 Class c1 = Integer.TYPE; Class c2 = Long.TYPE; 二、Java类反射中的主要方法对于以下三类组件中的任何一类来说-- 构造函数、字段和方法-- https://www.wendangku.net/doc/ed11198216.html,ng.Class 提供四种

Java反射机制与动态代理

前言，在Java运行时刻，能否知道一个类的属性方法并调用改动之？对于任意一个对象，能否知道他的所属类，并调用他的方法？答案是肯定的。这种动态的获取信息及动态调用方法的机制在Java中称为“反射”（reflection）。 Java反射机制主要提供以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法。 Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。在JDK中，主要由以下类来实现Java反射机制，这些类都位于 https://www.wendangku.net/doc/ed11198216.html,ng.reflect包中： Class类：代表一个类； Field 类：代表类的成员变量（成员变量也称为类的属性）； Method类：代表类的方法； Constructor 类：代表类的构造方法； Array类：提供了动态创建数组，以及访问数组的元素的静态方法；例程DateMethodsTest类演示了Reflection API的基本作用，它读取命令行参数指定的类名，然后打印这个类所具有的方法信息，代码如下： Java代码 1.public class DateMethodsTest 2.{ 3. public static void main(String args[]) throws Exception 4. { 5. // 加载并初始化命令行参数指定的类 6. Class classType = Class.forName("java.util.Date"); 7. // 获得类的所有方法 8. Method methods[] = classType.getDeclaredMethods(); 9. for (int i = 0; i < methods.length; i++) 10. { 11. System.out.println(methods[i].toString());

Java反射访问私有变量和私有方法

Java反射访问私有变量和私有方法引言对于软件开发人员来说，单元测试是一项必不可少的工作。它既可以验证程序的有效性，又可以在程序出现BUG 的时候，帮助开发人员快速的定位问题所在。但是，在写单元测试的过程中，开发人员经常要访问类的一些非公有的成员变量或方法，这给测试工作带来了很大的困扰。本文总结了访问类的非公有成员变量或方法的四种途径，以方便测试人员在需要访问类非公有成员变量或方法时进行选择。尽管有很多经验丰富的程序员认为不应该提倡访问类的私有成员变量或方法，因为这样做违反了Java 语言封装性的基本规则。然而，在实际测试中被测试的对象千奇百怪，为了有效快速的进行单元测试，有时我们不得不违反一些这样或那样的规则。本文只讨论如何访问类的非公有成员变量或方法，至于是否应该在开发测试中这样做，则留给读者自己根据实际情况去判断和选择。方法一：修改访问权限修饰符先介绍最简单也是最直接的方法，就是利用Java 语言自身的特性，达到访问非公有成员的目的。说白了就是直接将private 和protected 关键字改为public 或者直接删除。我们建议直接删除，因为在Java 语言定义中，缺省访问修饰符是包可见的。这样做之后，我们可以另建一个源码目录——test 目录（多数IDE 支持这么做，如Eclipse 和JBuilder），然后将测试类放到test 目录相同包下，从而达到访问待测类的成员变量和方法的目的。此时，在其它包的代码依然不能访问这些变量或方法，在一定程度上保障了程序的封装性。下面的代码示例展示了这一方法。清单1. 原始待测类 A 代码 public class A { private String name = null; private void calculate() { } }

java反射机制的作用

JAVA反射机制的原理是什么？运行时类型识别(Run-time Type Identification, RTTI)主要有两种方式，一种是我们在编译时和运行时已经知道了所有的类型，另外一种是功能强大的“反射”机制。要理解RTTI在Java中的工作原理，首先必须知道类型信息在运行时是如何表示的，这项工作是由“Class对象”完成的，它包含了与类有关的信息。类是程序的重要组成部分，每个类都有一个Class对象，每当编写并编译了一个新类就会产生一个Class对象，它被保存在一个同名的.class文件中。在运行时，当我们想生成这个类的对象时，运行这个程序的Java虚拟机(JVM)会确认这个类的Class 对象是否已经加载，如果尚未加载，JVM就会根据类名查找.class 文件，并将其载入，一旦这个类的Class对象被载入内存，它就被用来创建这个类的所有对象。一般的RTTI形式包括三种： ? 1.传统的类型转换。如“(Apple)Fruit”，由RTTI确保类型转换的正确性，如果执行了一个错误的类型转换，就会抛出一个ClassCastException异常。 ? 关于JA V A更多反射机制的资料以及跟高手学习机会，可以加到群422，然后就是912，加上最后的489，感觉还不错。现在才开始学反射机制没多久，差不多已经把这一块搞清楚了 ? ? 2.通过Class对象来获取对象的类型。如 Class c = Class.forName(“Apple”); Object o = c.newInstance(); ? ? 3.通过关键字instanceof或Class.isInstance()方法来确定对象是否属于某个特定类型的实例，准确的说，应该是instanceof / Class.isInstance()可以用来确定对象是否属于某个特定类及其所有基类的实例，这和equals() / ==不一样，它们用来比较两个对象是否属于同一个类的实例，没有考虑继承关系。 ?

java 6个机制

*克隆机制克隆就是在内存中复制对象，Java克隆(Clone)是Java语言的特性之一，但在实际中应用比较少见。但有时候用克隆会更方便更有效率。（缺点应该是多分配了一块空间，占内存吧，如果数据量大，内存占用的就大）对于克隆(Clone)，Java有一些限制： 1、被克隆的类必须自己实现Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。Cloneable 接口实际上是个标识接口，没有任何接口方法。 2、实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的）。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。 3、在https://www.wendangku.net/doc/ed11198216.html,ng.Object类中克隆方法是这么定义的： protected Object clone()throws CloneNotSupportedException{ } 创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。按照惯例，返回的对象应该通过调用 super.clone 获得。克隆分为深克隆和浅克隆浅度克隆：浅度克隆对于要克隆的对象，对于其基本数据类型的属性，复制一份给新产生的对象，对于非基本数据类型的属性，仅仅复制一份引用给新产生的对象，即新产生的对象和原始对象中的非基本数据类型的属性都指向的是同一个对象；深度克隆：在浅度克隆的基础上，对于要克隆的对象非基本数据类型的属性对应的类，也实现克隆，这样对于非基本数据类型的属性，复制的不是同一份引用，即新产生的对象和原始对象中的非基本数据类型的属性指向的不是同一个对象。 *序列化机制序列化也叫串行化，试讲对象转换成紧凑的二进制域的形式，使该对象具备可以被持久化即永久保存的特性。序列化的必要性 Java中，一切都是对象，在分布式环境中经常需要将Object从这一端网络或设备传递到另一端。这就需要有一种可以在两端传输数据的协议。Java序列化机制就是为了解决这个问题而产生。如何序列化一个对象

java反射原理

Java反射机制一、什么是反射机制简单的来说，反射机制指的是程序在运行时能够获取自身的信息。在java中，只要给定类的名字，那么就可以通过反射机制来获得类的所有信息。二、哪里用到反射机制有些时候，我们用过一些知识，但是并不知道它的专业术语是什么，在刚刚学jdbc时用过一行代码， Class.forName("com.mysql.jdbc.Driver.class").newInstance();但是那时候只知道那行代码是生成驱动对象实例，并不知道它的具体含义。听了反射机制这节课后，才知道，原来这就是反射，现在很多开框架都用到反射机制，hibernate、struts都是用反射机制实现的。三、反射机制的优点与缺点为什么要用反射机制？直接创建对象不就可以了吗，这就涉及到了动态与静态的概念，静态编译：在编译时确定类型，绑定对象,即通过。动态编译：运行时确定类型，绑定对象。动态编译最大限度发挥了java的灵活性，体现了多态的应用，有以降低类之间的藕合性。一句话，反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性，特别是在J2EE的开发中它的灵活性就表现的十分明显。比如，一个大型的软件，不可能一次就把把它设计的很完美，当这个程序编译后，发布了，当发现需要更新某些功能时，我们不可能要用户把以前的卸载，再重新安装新的版本，假如这样的话，这个软件肯定是没有多少人用的。采用静态的话，需要把整个程序重新编译一次才可以实现功能的更新，而采用反射机制的话，它就可以不用卸载，只需要在运行时才动态的创建和编译，就可以实现该功能。

它的缺点是对性能有影响。使用反射基本上是一种解释操作，我们可以告诉JVM，我们希望做什么并且它满足我们的要求。这类操作总是慢于只直接执行相同的操作。四、利用反射机制能获得什么信息一句话，类中有什么信息，它就可以获得什么信息，不过前提是得知道类的名字，要不就没有后文了首先得根据传入的类的全名来创建Class对象。 Class c=Class.forName("className");注明：className必须为全名，也就是得包含包名，比如， https://www.wendangku.net/doc/ed11198216.html,erInfo; Object obj=c.newInstance();//创建对象的实例 OK，有了对象就什么都好办了，想要什么信息就有什么信息了。获得构造函数的方法 Constructor getConstructor(Class[] params)//根据指定参数获得public构造器 Constructor[] getConstructors()//获得public的所有构造器 Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器 Constructor[] getDeclaredConstructors()//获得public的所有构造器获得类方法的方法 Method getMethod(String name, Class[] params),根据方法名，参数类型获得方法 Method[] getMethods()//获得所有的public方法 Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型，获得public和非public 的方法

JAVA反射

java 中的反射总结刚开始学习java的时候真的很难理解反射到底是个什么东西一些书籍，哪怕是很经典的书籍都解释的让人感觉懵懵的，或许的确是我太笨况且，网上说在将来学习框架的时候需要经常应用到反射机制，这样一来总让人心里有些不安就方才偶然又把讲解反射的章节和视频看了一点，觉得能理解一些了现在决定一鼓作气，边看边写，顺便把一些主要的内容和操作都记载到这里我想，对于我这么一个笨笨的人来说，学习的最好方法也许就是不断重复遇到不懂的知识就停下来把以往的重新学一遍，虽然浪费了很多时间，但对我也有些效果我的理解是：所谓反射，就是根据一个已经实例化了的对象来还原类的完整信息至少对我而言，我认为它带给我的好处是，让我从下往上的又了解了一遍面向对象 x_x 在此又痛恨一边那些厚部头们，把我的脑细胞搞死一片 Class类如果要完成反射，那么必须了解Class类实例1：通过对象取得包名和类名 1 2 3 4 5 6 7 8 9 10 11 12 13 package org.siu; class Test { } public class Demo { public static void main(String[] args) { Test t = new Test(); System.out.println(t.getClass()); System.out.println(t.getClass().getName()); } } 编译结果如下，注意包的编译方式即可此处的getClass()方法是默认继承自Object类的

在java中，Object类是所有类的父类，同样，所有类的实例化对象也都是Class类的实例因此，这样一来就会牵扯到向上转型和向下转型的概念由于向下转型的不安全因素，在这里泛型也会接踵而来（不过我想说的是，此处的泛型设计很刺眼！尼玛，整个java的语法设计同样刺眼，超恶心！！！）实例2：Class类的实例化由于Class类没有构造方法，所以实例化Class类的方式有点特殊，有三种方式： ?对象.getClass( ) ?类.Class ?forName( )

通过Java反射机制获取JavaBean对象

通过Java反射机制获取JavaBean对象目的 1.拼接SQL语句。 2.生成FORM表单。 3.获取JavaBean注解信息。 ... 源代码 package com.zc.util; import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Field; import https://www.wendangku.net/doc/ed11198216.html,ng.reflect.Method; import java.util.ArrayList; import java.util.Date; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import https://www.wendangku.net/doc/ed11198216.html,ment; /** * 通过Java反射机制获取JavaBean对象 * * @author张川(cr10210206@https://www.wendangku.net/doc/ed11198216.html,) * */ public class ReflectBeanUtil { //不属于JavaBean自身的属性 private static final String NOFIELDNAME = "serialVersionUID"; /** * 根据JavaBean获取属性名称和属性值 * * @param obj JavaBean对象 * */ public static Map getFieldByObj(Object obj){ Map params = new HashMap(); Field[] fields = obj.getClass().getDeclaredFields();