java反射型代码 java反射技术详解

用Eclipse写Java，反射的代码改写到哪里？~谢谢

和普通Java程序一样

package com;

public class Foo {

private String userName;

public Foo() {

// TODO Auto-generated constructor stub

}

public String getUserName() {

return userName;

}

public void setUserName(String userName) {

this.userName = userName;

}

public void outPrint() {

System.out.println("outPrint");

}

}

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

// TODO Auto-generated method stub

Class? fooClass = Class.forName("com.Foo");

for (int i = 0; i  (fooClass.getDeclaredMethods()).length; i++) {

System.out.println(fooClass.getMethods()[i]);

}

/*for (int i = 0; i  fooClass.getDeclaredFields().length; i++) {

System.out.println(fooClass.getDeclaredFields()[i]);

}*/

for (Field field : fooClass.getDeclaredFields()) {

System.out.println(field);

}

Method out = fooClass.getDeclaredMethod("outPrint");

Method get = fooClass.getDeclaredMethod("getUserName");

Method set = fooClass.getDeclaredMethod("setUserName", String.class);

//Foo foo = new Foo();

Object foo = fooClass.newInstance();

out.invoke(foo);

set.invoke(foo, "BO");

System.out.println(get.invoke(foo));

}

相关问答

Q1: java 通过反射 调用D盘中的类 这怎么实现？（要代码）

//fileName是你java反射型代码的java文件路径

//先编译java文件为class文件

JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();

StandardJavaFileManager fileMgr = compiler.getStandardFileManager(null, null, null);

Iterable units = fileMgr.getJavaFileObjects(fileName);

CompilationTask t = compiler.getTask(null, fileMgr,null, null, null, units);

t.call();

fileMgr.close();

//反射来加载class文件java反射型代码，假设你java反射型代码的类为A，最好写个接口B，让A 实现这个接口

B a = (B)Class.forName("包名.A");

Q2: java反射怎么实现的

Java中反射有如下几种实现方式：

1、通过Class.forName()方法加载字符串，就可以得到该字符串做代表的Class对象。

2、通过类名调用class属性得到该类的Class对象。

例如：Class? clazz = String.class也可以得到String类的Class对象。

3、调用实例的getClass()方法。

例如：Date date = new Date();

Class? clazz = date.getClass();

通过上边的两句代码就可以得到date实例的Class对象。

Q3: java反射提基本类型

使用类字面常量或TYPE字段java反射型代码，例如：

Class myObjectClass= MyObject.class；(类字面常量不仅可以应用于普通的类，也可以应用

于接口、数组以及基本数据类型)，这种方式不仅更简单，而且更安全，因为它在编译时就会受到检查，并且根除java反射型代码了对forName方法的调用，所以也更高效，建议使用“.class”的形式。

Class c = Integer.TYPE；（TYPE是基本数据类型的包装类型的一个标准字段，它是一

个引用，指向对应的基本数据类型的Class对象），附表如下，两边等价：

boolean.class

Boolean.TYPE

char.class

Character.TYPE

byte.class

Byte.TYPE

short.class

Short.TYPE

int.class

Integer.TYPE

long.class

Long.TYPE

float.class

Float.TYPE

double.class

Double.TYPE

void.class

Void.TYPE

Q4: Java中的反射

clazz构造方法是用的数组

你反射出来也得用数组啊

改成

Constructor con=clazz.getConstructor(new Class[]{String.class});

试试

Q5: 实用的Java反射工具类

反射的Utils函数集合

提供访问私有变量 获取泛型类型Class 提取集合中元素的属性等Utils函数

package reflection

import java lang reflect Field import java lang reflect Modifier import java lang reflect ParameterizedType import java lang reflect Type import java util ArrayList import java util Collection import java util List

import mons beanutils PropertyUtils import mons lang StringUtils import slf j Logger import slf j LoggerFactory import springframework util Assert

/** * 反射的Utils函数集合 提供访问私有变量 获取泛型类型Class 提取集合中元素的属性等Utils函数

* * @author lei */ public class ReflectionUtils {

private static Logger logger = LoggerFactory getLogger（ReflectionUtils class）

private ReflectionUtils（） { }

/** * 直接读取对象属性值 无视private/protected修饰符 不经过getter函数

*/ public static Object getFieldValue（final Object object final String fieldName） { Field field = getDeclaredField（object fieldName）

if （field == null）

throw new IllegalArgumentException（ Could not find field [ + fieldName + ] on target [ + object + ] ）

makeAccessible（field）

Object result = null try { result = field get（object） } catch （IllegalAccessException e） { logger error（ 不可能抛出的异常{} e getMessage（）） } return result }

/** * 直接设置对象属性值 无视private/protected修饰符 不经过setter函数

*/ public static void setFieldValue（final Object object final String fieldName final Object value） { Field field = getDeclaredField（object fieldName）

if （field == null）

throw new IllegalArgumentException（ Could not find field [ + fieldName + ] on target [ + object + ] ）

makeAccessible（field）

try { field set（object value） } catch （IllegalAccessException e） { logger error（ 不可能抛出的异常 {} e getMessage（）） } }

/** * 循环向上转型 获取对象的DeclaredField */ protected static Field getDeclaredField（final Object object final String fieldName） { Assert notNull（object object不能为空 ） return getDeclaredField（object getClass（） fieldName） }

/** * 循环向上转型 获取类的DeclaredField */ @SuppressWarnings（ unchecked ）

protected static Field getDeclaredField（final Class clazz final String fieldName） { Assert notNull（clazz clazz不能为空 ） Assert hasText（fieldName fieldName ） for （Class superClass = clazz superClass ！= Object class superClass = superClass getSuperclass（）） { try { return superClass getDeclaredField（fieldName） } catch （NoSuchFieldException e） { // Field不在当前类定义 继续向上转型 } } return null }

/** * 强制转换fileld可访问

*/ protected static void makeAccessible（final Field field） { if （！Modifier isPublic（field getModifiers（）） || ！Modifier isPublic（field getDeclaringClass（） getModifiers（））） { field setAccessible（true） } }

/** * 通过反射 获得定义Class时声明的父类的泛型参数的类型 如public UserDao extends HibernateDaoUser * * @param clazz *            The class to introspect * @return the first generic declaration or Object class if cannot be *         determined */ @SuppressWarnings（ unchecked ）

public static Class getSuperClassGenricType（final Class clazz） { return getSuperClassGenricType（clazz ） }

/** * 通过反射 获得定义Class时声明的父类的泛型参数的类型 如public UserDao extends * HibernateDaoUser Long * * @param clazz *            clazz The class to introspect * @param index *            the Index of the generic ddeclaration start from * @return the index generic declaration or Object class if cannot be *         determined */

@SuppressWarnings（ unchecked ）

public static Class getSuperClassGenricType（final Class clazz final int index） {

Type genType = clazz getGenericSuperclass（）

if （！（genType instanceof ParameterizedType）） { logger warn（clazz getSimpleName（） + s superclass not ParameterizedType ） return Object class }

Type[] params = （（ParameterizedType） genType） getActualTypeArguments（）

if （index = params length || index ） { logger warn（ Index + index + Size of + clazz getSimpleName（） + s Parameterized Type + params length） return Object class } if （！（params[index] instanceof Class）） { logger warn（clazz getSimpleName（） + not set the actual class on superclass generic parameter ） return Object class } return （Class） params[index] }

/** * 提取集合中的对象的属性 组合成List * * @param collection *            来源集合

* @param propertityName *            要提取的属性名

*/ @SuppressWarnings（ unchecked ）

public static List fetchElementPropertyToList（final Collection collection final String propertyName） throws Exception {

List list = new ArrayList（）

for （Object obj collection） { list add（PropertyUtils getProperty（obj propertyName）） }

return list }

/** * 提取集合中的对象的属性 组合成由分割符分隔的字符串

* * @param collection *            来源集合

* @param propertityName *            要提取的属性名

* @param separator *            分隔符

*/ @SuppressWarnings（ unchecked ）

lishixinzhi/Article/program/Java/hx/201311/26718

java反射型代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java反射技术详解、java反射型代码的信息别忘了在本站进行查找喔。