`
aimer311
  • 浏览: 96451 次
  • 性别: Icon_minigender_1
  • 来自: 厦门
社区版块
存档分类
最新评论

反射中如何区分参数是基本类型还是所对应的包装类

    博客分类：
  • java
J# 
阅读更多 
package demo.test;

import java.lang.reflect.Method;

/**
 * Java Reflection Cookbook<br/>
 * eg:<br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;Reflection r = new Reflection(A.class);<br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;Reflection r = new Reflection("com.ehi.A");<br/>
 */
@SuppressWarnings("unchecked")
public class Reflection {

	private Class clazz;

	private Object object;
	
	private Reflection() {

	}

	/**
	 * construct method
	 * @param obj
	 */
	public Reflection(Object obj) {
		this.object = obj;
		clazz = obj.getClass();
	}

	/**
	 * construct method
	 * @param className
	 * @throws Exception
	 */
	public Reflection(String className) throws Exception {
		if (className == null)
			clazz = null;
		else
			clazz = Class.forName(className);
		this.object = clazz.newInstance();
	}
	
	/**
	 * 根据方法名，参数，查找对应的方法，并执行
	 * 
	 * @param methodName
	 *            方法名
	 * @param args
	 *            参数
	 * @return 方法返回值
	 * @throws Exception
	 */
	public Object invoke(String methodName, Object[] args)
			throws Exception {
		Class[] parameterTypes = getParameterTypes(args);
		Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
		method.setAccessible(true); 
		return method.invoke(object, args);
	}
	
	private Class[] getParameterTypes(Object[] args) throws Exception {
		if(args == null){
			return null;
		}
		Class[] parameterTypes = new Class[args.length];
		for (int i = 0, j = args.length; i < j; i++) {
			if(args[i] instanceof Integer){
				parameterTypes[i] = Integer.TYPE;
			}else if(args[i] instanceof Byte){
				parameterTypes[i] = Byte.TYPE;
			}else if(args[i] instanceof Short){
				parameterTypes[i] = Short.TYPE;
			}else if(args[i] instanceof Float){
				parameterTypes[i] = Float.TYPE;
			}else if(args[i] instanceof Double){
				parameterTypes[i] = Double.TYPE;
			}else if(args[i] instanceof Character){
				parameterTypes[i] = Character.TYPE;
			}else if(args[i] instanceof Long){
				parameterTypes[i] = Long.TYPE;
			}else if(args[i] instanceof Boolean){
				parameterTypes[i] = Boolean.TYPE;
			}else{
				parameterTypes[i] = args[i].getClass();
			}
		}
		return parameterTypes;
	}
	
	public void print(Integer i){
		System.out.println("Integer: "+i.intValue());
	}
	
	public void print(int i){
		System.out.println("int: "+i);
	}
	
	public static boolean isWrapClass(Class clz) {
        try {
            return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
        } catch (Exception e) {
            return false;
        }
    } 
	
	public static void main(String[] args) throws Exception {
		Reflection r = new Reflection(new Reflection());
		Object[] obj = new Object[1];
		int i = 333;
		obj[0] = i;
                //Integer I = new Integer(333);
                //obj[0] = I;
		r.invoke("print", obj);
	}
}

invoke要实现的是根据方法名和输入的参数自动查找对应的方法，并执行之。遇到的问题就是如何区分Object[]里面存储的是一个基本类型还是其对应的包装类？或者这样的思路根本就是有问题的，请提供下其他的思路。
1
顶
2
踩
分享到：
| 在drools规则条件中使用日期进行比较
评论
3 楼 realorg 2008-11-27  
请问 JDK1.4 里能这么做么？
2 楼 aimer311 2008-10-10  
当程序执行到如下时：
int i = 333; 
obj[0] = i; 内存实际上存储的是一个Integer对象。
也就是说当把i存储到数组后就已经是一个Integer的对象了，那么以后就没办法知道它具体是从对象定义而来还是具体类型而来了。
所以我在想除非在传入的参数中必须包含它具体定义类型的信息。
如：
    定义的是int i = 333;那么加上类型信息int.class
    定义的是Integer I = 333,那么加上类型信息Integer.class.
这样是比较麻烦一点。
当调用的函数包含有基本类型的包装类时，那么必须传入参数的具体类型，否则不需要。因为传入包装类的情况比较少，当然也可以判断当传入的是基本类型是必须加上类型信息。根据上面的想法修改后的程序如下：
package demo.test;

import java.lang.reflect.Method;

/**
 * Java Reflection Cookbook<br/>
 * eg:<br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;Reflection r = new Reflection(A.class);<br/>
 * &nbsp;&nbsp;&nbsp;&nbsp;Reflection r = new Reflection("com.ehi.A");<br/>
 */
@SuppressWarnings("unchecked")
public class Reflection {

	private Class clazz;

	private Object object;
	
	private Reflection() {

	}

	/**
	 * construct method
	 * @param obj
	 */
	public Reflection(Object obj) {
		this.object = obj;
		clazz = obj.getClass();
	}

	/**
	 * construct method
	 * @param className
	 * @throws Exception
	 */
	public Reflection(String className) throws Exception {
		if (className == null)
			clazz = null;
		else
			clazz = Class.forName(className);
		this.object = clazz.newInstance();
	}
	
	/**
	 * 执行对象方法
	 * 当所执行的函数的参数包含基本类型的包装类是，必须为所有参数定义其参数类型
	 * @param methodName
	 *            方法名
	 * @param args
	 *            参数
	 * @param types
	 * 				当函数的参数包含基本类型的包装类时，此参数包含所以参数的类型信息
	 * @return 方法返回值
	 * @throws Exception
	 */
	public Object invoke(String methodName, Object[] args, Class[] types)
			throws Exception {
		Class[] parameterTypes = null;
		if(types == null)
			parameterTypes = getParameterTypes(args);
		else
			parameterTypes = types;
		Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
		method.setAccessible(true); 
		return method.invoke(object, args);
	}
	
	private Class[] getParameterTypes(Object[] args) throws Exception {
		if(args == null){
			return null;
		}
		Class[] parameterTypes = new Class[args.length];
		for (int i = 0, j = args.length; i < j; i++) {
			if(args[i] instanceof Integer){
				parameterTypes[i] = Integer.TYPE;
			}else if(args[i] instanceof Byte){
				parameterTypes[i] = Byte.TYPE;
			}else if(args[i] instanceof Short){
				parameterTypes[i] = Short.TYPE;
			}else if(args[i] instanceof Float){
				parameterTypes[i] = Float.TYPE;
			}else if(args[i] instanceof Double){
				parameterTypes[i] = Double.TYPE;
			}else if(args[i] instanceof Character){
				parameterTypes[i] = Character.TYPE;
			}else if(args[i] instanceof Long){
				parameterTypes[i] = Long.TYPE;
			}else if(args[i] instanceof Boolean){
				parameterTypes[i] = Boolean.TYPE;
			}else{
				parameterTypes[i] = args[i].getClass();
			}
		}
		return parameterTypes;
	}
	
	public void print(Integer i, int j){
		System.out.println("Integer: "+i.intValue());
		System.out.println("int: "+j);
	}
	
	public void print(int i){
		System.out.println("int: "+i);
	}
	
	public static boolean isWrapClass(Class clz) {
        try {
            return ((Class) clz.getField("TYPE").get(null)).isPrimitive();
        } catch (Exception e) {
            return false;
        }
    } 
	
	public static void main(String[] args) throws Exception {
		Reflection r = new Reflection(new Reflection());
		Object[] obj = new Object[2];
		Integer I = new Integer(333);
		obj[0] = I;
		obj[1] = 444;
		Class[] clazz = new Class[2];
		clazz[0] = Integer.class;
		clazz[1] = int.class;
		r.invoke("print", obj, clazz);
	}
}
1 楼 aimer311 2008-10-09  
按照以上的程序并不能调用print(Integer i).当然，我知道通过
Method method = clazz.getDeclaredMethod("print", int.class);
Method method = clazz.getDeclaredMethod("print", Integer.class);可以区分这两个函数，这样相当于实现知道参数类型。而如果从所输入的参数来判断是什么类型，再判断调用哪个函数就不清楚了。如：
当obj[0] = 333,表明此时的参数是int型，那么调用的应该是print(int i);
当obj[0] = new Integer(333),表明此时的参数是Integer型，那么调用的应该是print(Integer i);


发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java反射-英文版反射规范

    通过反射可以获取原始类型的包装类，并且可以转换为对应的原始类型。 ##### 1. **原始类型的包装类** - 每个原始类型都有一个对应的包装类（如Integer对应int）。 - 通过反射可以方便地在这两者之间进行转换。 #...

    java反射例子，封装了一个反射帮助类

    这样的类通常会提供一些静态方法，这些方法对上述反射操作进行了包装，使得代码更简洁、易读。例如，可能会有一个`createInstance(String className, Object[] params)`方法，用于处理创建对象的各种情况，或者`...

    Java方法反射调用demo

    对于基本类型参数，如`int`，由于Java的类型擦除，我们需要使用对应的包装类。例如，对于`int`类型的参数： ```java Method method = MyClass.class.getMethod("myMethodWithIntArg", Integer.class); method....

    java反射之动态代理

    注意，如果参数是基本类型，必须转换成对应的包装类对象。`invoke()`方法的返回值也是对象，即使是基本类型，也会被包装成相应的包装类对象。 在代码的最后，我们分别调用了`method1`、`method2`和`method3`所代表...

    T网络程序设计应用与反射机制PPT教案.pptx

    - 基本类型的包装类如`Integer`提供了`.TYPE`属性，可以直接获取对应基本类型的`Class`对象。 `Class`类还提供了以下关键方法： - `newInstance()`：使用默认的构造器创建类的新实例，要求类必须有无参构造器。 - `...

    解析Java中的Field类和Method类

    `get()`返回字段值的对象，如果字段是基本类型，会返回相应包装类的对象，可以通过自动拆箱赋值给基本类型的变量。`set()`方法接受一个对象和新值，用于修改字段的值，对于基本类型，可以直接传入基本类型的值，系统...

    C++ reflect 反射

    首先，我们需要了解C++20中的`std::reflect::metaobject`，它是类型信息的表示。每个类型都有一个唯一的`metaobject`，它包含了关于该类型的元数据，如其成员函数、数据成员等。`std::reflect::reflect`函数用于获取...

    使用Java反射机制将Map转换为Java对象，支持Boolean、Date类型

    对于Date和Boolean类型，我们需要额外处理，因为它们不是Java的基本类型，而是包装类。 对于Date类型，我们需要先创建一个Date对象，然后调用setter方法。假设我们有一个名为`MyObject`的类，其中有一个`Date`类型...

    java反射原理

    - **方法二**：对于基本数据类型，可以直接使用包装类的`TYPE`属性。 ```java Class&lt;?&gt; c = Integer.TYPE; ``` - **方法三**：通过对象的`getClass()`方法。 ```java String s = new String(); Class&lt;?&gt; c = ...

    Java基础题目.pdf

    - 当需要对基本数据类型进行装箱（即转换为对应的包装类对象）或拆箱（即从包装类中提取基本数据类型值）操作时，可以使用自动装箱和拆箱机制。 2. **类型转换**： - Java中存在自动类型转换和强制类型转换。 - ...

    CLR.via.C#.(中文第3版)(自制详细书签)Part2

    17.7.3 简化语法3：局部变量不需要手动包装到类中即可传给回调方法 17.8 委托和反射 第18章 定制attribute 18.1 使用定制attribute 18.2 定义自己的attribute类 18.3 attribute的构造器和字段/属性的数据类型 ...

    JAVA基础面试题,包含答案

    包装类提供了将基本数据类型转换为其他类型的方法，如 Integer.valueOf() 和 Integer.parseInt()。包装类广泛应用于数据类型的转换中。 三、 重载和重写的区别 重写（override）是子类中对父类方法的重写，要求...

    java 根据javaBean反射自定义导出 excel、xml、pdf、csv

    在Java编程中，根据JavaBean反射来实现数据的导出，如Excel、XML、PDF和CSV格式，是一种常见的数据处理技术。JavaBean是Java中的一种设计模式，它提供了一种标准的方式来封装对象属性，便于数据操作。反射机制则是...

    经典java面试题30道

    Java 中的包装类是基本数据类型的对象形式，例如 Integer 对应 int，Double 对应 double 等。常见的包装类包括 Integer、Double、Boolean 等。 4. String 类和 StringBuilder/StringBuffer 类 String 类是不可变的...

    Java反射机制

    5. **使用基本类型包装类的TYPE语法**：这种方式适用于获取基本类型的Class对象。例如： ```java Class&lt;?&gt; c = int.class; Class&lt;?&gt; d = double.class; ``` #### 五、动态生成实例 在反射机制中，有几种不同的...

    JAVA5.0泛型指南

    例如，`ArrayList&lt;T&gt;` 就是一个泛型类，`T` 是类型参数，代表列表中的元素类型。通过实例化时指定具体的类型，如 `ArrayList&lt;String&gt;`，我们可以确保列表只能存储字符串，避免了类型转换的麻烦和可能的...

    java函数速查中文版

    3. **自动装箱与拆箱**：在JDK 1.5后，Java引入了基本类型对应的包装类，如`Integer`、`Double`等。自动装箱是指将基本类型自动转换为对应的包装类对象，拆箱则是反之。这使得操作基本类型和对象更加方便。 4. **...

    jdk5_64.zip

    在JDK5之前，Java中基本类型与对应的包装类之间无法直接转换，需要手动装箱和拆箱。JDK5引入了自动装箱和拆箱机制，使得基本类型与包装类之间的转换变得无缝且高效，提升了编程的便利性。 四、变长参数（Varargs） ...

Magicbox
Global site tag (gtag.js) - Google Analytics