java中反射的类

㈠ java中什么是反射，反射怎么用，什么场景用有没有替代方案

1、反射简言之就是在编译时无法拿到某一个类，但是可以在运行时动态获取这个类，这样去使用某一个类，就是反射的使用场景。
2、代替反射或者类似的操作，可以通过DI实现IOC .依赖注入，动态代理。

㈡ java反射提基本类型

使用类字面常量或TYPE字段，例如：
Class myObjectClass= MyObject.class；(类字面常量不仅可以应用于普通的类，也可以应用
于接口、数组以及基本数据类型)，这种方式不仅更简单，而且更安全，因为它在编译时就会受到检查，并且根除了对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

㈢ JAVA中反射是什么

JAVA中反射是动态获取信息以及动态调用对象方法的一种反射机制。

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。

Java反射的功能是在运行时判断任意一个对象所属的类，在运行时构造任意一个类的对象，在运行时判断任意一个类所具有的成员变量和方法，在运行时调用任意一个对象的方法，生成动态代理。

(3)java中反射的类扩展阅读：

JAVA中反射实例：

1、Class superClass=clazz.getSuperclass();//获取父类。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//获取实现接口。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//构造方法。

System.out.println("getConstructors:"+cons.length)。

参考资料来源：网络： JAVA反射机制

㈣ 实用的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 HibernateDao<User> * * @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 * HibernateDao<User 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 ）

㈤ Java里面反射的原理是什么

java虚拟机运行时内存有个叫方法区，主要作用是存储被装载的类的类型信息。每装载一个类的时候，java就会创建一个该类的Class对象实例。我们就可以通过这个实例，来访问这个类的信息。

㈥ 在JAVA中，怎么利用反射获取一个方法

java的反射用法：(异常请自行处理)

①找到类：Class cl = Class.forName("java.util.Date");

②创建对象(要求这个类中含有空参数的构造方法)：Object obj = cl.newInstence();

③根据名称和参数找方法：Method method1 = cl.getMethod("getTime");//如果没有参数不用写第二个参数如果有参数的如：Method method2 = cl.getMethod("setTime",long.class);

④在某个对象上面执行方法，Object result = method1.invoke(obj);//如果有参数的Object result = method2.invoke(obj,21317362721);

执行的方如果有返回值，将返回值返回，否则返回null

㈦ java中反射的三种方法是

第一种：通过forName()方法；

第二种：类.class；

第三种：对象.getClass()。

举例如下：

package
test;

public class Demo{

public static void
main(){

Class<?> c1 = null;

Class<?> c2 =
null;

Class<?> c3 =
null;

//三种反射用实例化方式

try{

//最常用的一种形式

c1 =
Class.forName("test.X");

}catch(ClassNotFoundException
e){

e.printStackTrace();

}

//通过Object类中的方法实例化

c2
= new X().getClass();

//通过类.class实例化

c3 =
X.class;

System.out.println("类名：" + c1.getName());
//得到类名

System.out.println("类名：" + c2.getName());
//得到类名

System.out.println("类名：" + c3.getName());
//得到类名

}

}