精华内容
下载资源
问答
  • java 反射数组参数方法 如何反射
    2021-02-26 11:03:41

    publicdoublecompareListSameMore(String...str){doubleresult=NONMATCH;Listlist=newArrayList();//String[]str=(String[])strObject;if(str.length%2==0){String...

    public double compareListSameMore(String... str) {

    double result = NONMATCH;

    List list = new ArrayList();

    //String[] str = (String[])strObject;

    if (str.length % 2 == 0){

    String[] sek = str[1].split(SPLITSTR);

    for (int y=0; y

    if (sek[y].toString().indexOf(Integer.parseInt(str[0])) != -1){

    list.add(y);

    result = MATCH;

    }

    }

    return result;

    }

    需要反射的方法。

    反射方法

    public Object invokeMethod(Object owner, String methodName, Object[] args)

    throws Exception {

    Class ownerClass = owner.getClass();

    Class[] argsClass = new Class[args.length];

    for (int i = 0, j = args.length; i < j; i++) {

    argsClass[i] = args[i].getClass();

    }

    Object result = null;

    Method method = null;

    try{

    method = ownerClass.getDeclaredMethod(methodName, argsClass);

    } catch (Exception e){

    //e.printStackTrace();

    }

    try {

    if (method == null) {

    for (Method m : ownerClass.getDeclaredMethods()) {

    if (m.getName().equals(methodName)) {

    boolean find = true;

    Class[] paramType = m.getParameterTypes();

    if (paramType.length != argsClass.length) {

    if ()){

    /**

    * 这里需要大家的帮助 */

    参数值,m.getName()找了类名,compareListSameMore。 argsClass,class[10] Class java.lang.String。 Class[] paramType,length =1, 类型:[class[Ljava.lang.String;]。

    我想实现,可以放射到方法类。我执行的结果,都是抛出参数个数不同的异常。

    谢谢。

    }else{

    continue;

    }

    }else{

    for (int i=0; i

    if (! paramType[i].isAssignableFrom(argsClass[i])) {

    find = false;

    break;

    }

    }

    }

    if (find) {

    method = m;

    break;

    }

    }

    }

    }

    if (method != null) {

    result = method.invoke(owner, args);

    }

    } catch (Exception e) {

    e.printStackTrace();

    }

    return result;

    }

    展开

    更多相关内容
  • 主要介绍了详解java反射机制(含数组参数)的相关资料,希望通过本文能帮助到大家,让大家理解掌握这部分内容,需要的朋友可以参考下
  • java反射机制允许在不显式调用类及类方法的前提下,实现创建类对象、调用类方法等一系列操作。在使用反射机制时,如果遇到类方法的参数中含有数组,情况稍有不同。如果数组参数为基本数据类型,如String、int等,则...

    java反射机制允许在不显式调用类及类方法的前提下,实现创建类对象、调用类方法等一系列操作。

    在使用反射机制时,如果遇到类方法的参数中含有数组,情况稍有不同。如果数组参数为基本数据类型,如String、int等,则相对简单:

    Class> tmp = Class.forName("testReflection");

    Method m = tmp.getMethod("test", new Class[]{String[].class});

    m.invoke(tmp.newInstance(),new String[]{"hi"});

    如果数组参数为复杂数据类型,情况就较为复杂,以自定义类数组参数为例,样例如下。希望用反射调用Person类的setParents方法,而setParents方法的参数为Relative对象的数组:

    package com.ashu.test;

    import java.lang.reflect.InvocationTargetException;

    public class TestReflection {

    public static void main(String[] args) throws ClassNotFoundException,

    InstantiationException, IllegalAccessException,

    IllegalArgumentException, SecurityException,

    InvocationTargetException, NoSuchMethodException {

    Class> relativeClass = Class.forName("com.ashu.test.Relative");

    Object relativeFather = relativeClass.newInstance();

    Object relativeMother = relativeClass.newInstance();

    relativeClass.getMethod("setName", String.class).invoke(relativeFather,

    "father");

    relativeClass.getMethod("setName", String.class).invoke(relativeMother,

    "mother");

    Class> personClass = Class.forName("com.ashu.test.Person");

    Object personObject = personClass.newInstance();

    Class> relativeClassArray = Class

    .forName(new Relative[] {}.getClass().getName());

    Object[] temp = (Object[]) java.lang.reflect.Array.newInstance(

    relativeClass, 2);

    temp[0] = relativeFather;

    temp[1] = relativeMother;

    personClass.getMethod(

    "setParents",

    java.lang.reflect.Array.newInstance(relativeClass, 2)

    .getClass()).invoke(personObject,

    relativeClassArray.cast(temp));

    personClass.getMethod("getParents").invoke(personObject);

    }

    }

    class Person {

    private Relative[] parents;

    public void getParents() {

    for (Relative r : parents)

    r.getName();

    }

    public void setParents(Relative[] parents) {

    this.parents = parents;

    }

    }

    class Relative {

    private String name;

    public void getName() {

    System.out.println(name);

    }

    public void setName(String name) {

    this.name = name;

    }

    }

    在反射的使用中,主要步骤有两个:

    1、找到Person的setParents方法。在输入setParents的参数类时,不能直接用relativeClass,而应该用其数组形式。不能像基本数据类型那样直接加[],只能通过new出数组,再getClass的方法来确定:java.lang.reflect.Array.newInstance(relativeClass, 2).getClass()

    2、给setParents方法传参。由于参数类型为对象数组,如果直接用new Object[]{relativeFather, relativeMother}的形式会报错,此时需要进行先找到对象数组的类(new Relative[] {}.getClass()),再用这个类对new出来的Object数组进行强转,这也是本方法的核心。

    展开全文
  • java 反射数组

    2021-02-25 19:22:50
    反射中可能用到的两个比较特殊的类型,数组和枚举,分别对应java.lang.reflect.Array和java.lang.Enum,后者其实并不是反射类库包中的类,但是反射的基础类库里面有使用枚举类型的方法数组数组是由Java虚拟机实现(这...

    反射中可能用到的两个比较特殊的类型,数组和枚举,分别对应java.lang.reflect.Array和java.lang.Enum,后者其实并不是反射类库包中的类,但是反射的基础类库里面有使用枚举类型的方法

    数组

    数组是由Java虚拟机实现(这一点很重要,这就是为什么JDK类库中没有数组对应的类型的原因,array也不是Java中的保留关键字,操作数组的底层方法都是native方法),数组类型只有继承自java.lang.Object的方法,数组的length方法实际上并不属于数组类型的一部分,数组的length方法其实最终调用的是java.lang.reflect.Array#getLength(),注意到这个方法是native方法。java.lang.reflect.Array是基于反射操作数组的核心类。

    使用反射方式就是使用java.lang.reflect.Array中的相关方法:

    int[] arr = new int[10];

    Class> c = Class.forName(cName);

    Object o = Array.newInstance(c, n);

    for (int i = 0; i < n; i++) {

    String v = cVals[i];

    Constructor ctor = c.getConstructor(String.class);

    Object val = ctor.newInstance(v);

    Array.set(o, i, val);

    }

    Object[] oo = (Object[]) o;

    因为Java泛型擦除的问题,实际上我们使用Array#newInstance方法只能得到一个Object类型的结果实例,其实这个结果实例的类型就是ComponentType[],这里只是返回了它的父类(Object)类型实例,因此我们可以直接强转,例如:

    String[] strArray = (String[]) Array.newInstance(String.class, 3);

    反射条件下,可以通过Class.forName()获取数组类型,但是调用此方法的时候有个限制,类名必须使用JVM可以识别的签名形式,就是[L${ComponentType};,注意Class.forName()无法获取原始类型(如int、boolean)的类型

    Double[] a=new Double[2];

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

    System.out.println(double[].class);

    Class> aClass = Class.forName("[Ljava.lang.Double;");

    System.out.println(aClass);

    class [Ljava.lang.Double;

    class [D

    class [Ljava.lang.Double;

    获取数组元素(组件)类型:Class#getComponentType()

    枚举

    所有枚举都继承自java.lang.Enum

    boolean java.lang.Class#isEnum():判断类型是否枚举类型。

    T[] java.lang.Class#getEnumConstants():获取类型中所有的枚举常量。

    boolean java.lang.reflect.Field#isEnumConstant():判断属性是否枚举类型。

    1、枚举类型会变成一个普通Java类,这个Java类会继承java.lang.Enum,并且把自身类型作为泛型参数类型,构造函数中必定包含name(字符串类型String)、ordinal(整型int)参数,因为父类java.lang.Enum的构造要求传入这两个参数。

    2、所有的枚举成员属性都变成static final修饰的在第1步中提到的Java类的实例,属性的名称和原来枚举的名字一致,实例在静态代码块中创建。

    3、新增了一个static final修饰的第1步中提到的Java类的数组实例,名称为$VALUES,此数组在静态代码块中创建,基于此数组还新增了一个静态方法values(),此方法就是直接返回数组的克隆。

    public class EnumerationMain {

    enum Color {

    RED, BLACK, BLUE

    }

    public static class ColorHolder {

    private Color color = Color.BLACK;

    }

    public static void main(String[] args) throws Exception {

    Class colorClass = Color.class;

    System.out.println("Color class is enum:" + colorClass.isEnum());

    System.out.println("Color values:" + Arrays.toString(colorClass.getEnumConstants()));

    ColorHolder colorHolder = new ColorHolder();

    Class holderClass = ColorHolder.class;

    Field field = holderClass.getDeclaredField("color");

    field.setAccessible(true);

    System.out.println("Old color:" + field.get(colorHolder));

    field.set(colorHolder, Color.RED);

    System.out.println("New color:" + field.get(colorHolder));

    }

    }

    Color class is enum:true

    Color values:[RED, BLACK, BLUE]

    Old color:BLACK

    New color:RED

    展开全文
  • Java反射-数组

    2021-02-12 18:57:05
    通过反射使用数组有时会比较棘手。特别是需要获得一个特定类型数组的Class对象,如int[]等。本文将讨论如何通过反射创建数组和获得他们的Class对象。注意:本文在阅读Eyal Lupu的博客"Two Side Notes About Arrays ...

    通过反射使用数组有时会比较棘手。特别是需要获得一个特定类型数组的Class对象,如int[]等。本文将讨论如何通过反射创建数组和获得他们的Class对象。

    注意:本文在阅读Eyal Lupu的博客"Two Side Notes About Arrays and Reflection"后已更新,他的博客是本文第一个版本的评论。当前版本考虑了他的评论内容。

    java.lang.reflect.Array

    数组反射是通过类java.lang.reflect.Array实现的。不要把这个类与集合包的java.util.Arrays混淆,java.util.Arrays包含数组排序、转换成集合等。

    Creating Arrays

    通过反射创建数组是java.lang.reflect.Array实现的。示例代码如下:

    int[] intArray = (int[]) Array.newInstance(int.class, 3);

    示例代码创建了一个int数组。Array.newInstance()方法的第一个参数int.class定义了数组每一个元素的类型。第二个参数定义数组的元素个数。

    Accessing Arrays

    可以通过反射访问数组元素。这是通过Array.get(...)和Array.set(...)方法实现的。示例:

    int[] intArray = (int[]) Array.newInstance(int.class, 3);

    Array.set(intArray, 0, 123);

    Array.set(intArray, 1, 456);

    Array.set(intArray, 2, 789);

    System.out.println("intArray[0] = " + Array.get(intArray, 0));

    System.out.println("intArray[1] = " + Array.get(intArray, 1));

    System.out.println("intArray[2] = " + Array.get(intArray, 2));

    示例代码将输出:

    intArray[0] = 123

    intArray[1] = 456

    intArray[2] = 789

    Obtaining the Class Object of an Array

    在实现Butterfly DI Container的脚本语言时一个问题就是如何通过反射获得数组的Class对象。无反射代码如下:

    Class stringArrayClass = String[].class;

    做这些使用Class.forName()并不是直接了当。例如,访问原始int数组类对象代码:

    Class intArray = Class.forName("[I");

    JVM使用小写l代表int。左边的[的意思是它是我有兴趣的int数组的类对象。其他基本类型也是按照这个模式工作。

    对于其他类型对象,需要使用稍微不同的符号:

    Class stringArrayClass = Class.forName("[Ljava.lang.String;");

    注意:[L在类名的左侧,;在类名的右侧。这段代码的意思是给定类型的数组对象。

    作为旁注,你不能使用Class.forName()获得基本类型的类对象。下面的两行代码都会抛出ClassNotFoundException:

    Class intClass1 = Class.forName("I");

    Class intClass2 = Class.forName("int");

    我通常使用像下面的代码获得基本类型的类对象:

    public Class getClass(String className){

    if("int" .equals(className)) return int .class;

    if("long".equals(className)) return long.class;

    ...

    return Class.forName(className);

    }

    一旦你获得一个类型的Class对象,很简单就能获得这个类型的数组的Class对象。这个解决方案,或者叫它解决办法,是创建指定类型的空数组并通过空数组获得Class对象。这并不很优雅,但是有效。代码如下:

    Class theClass = getClass(theClassName);

    Class stringArrayClass = Array.newInstance(theClass, 0).getClass();

    这提供了一种单一的、统一的方法来访问任何类型的数组的数组类。不要摆弄类名等。

    为了确保Class对象确实是一个数组,可以调用Class.isArray()方法来检查:

    Class stringArrayClass = Array.newInstance(String.class, 0).getClass();

    System.out.println("is array: " + stringArrayClass.isArray());

    Obtaining the Component Type of an Array

    一旦你获得数组的Class对象,你可以通过Class.getComponentType()访问它的组合类型。组合类型是数组中的元素的类型。例如,int[]数组的组合类型是int.class的Class对象。String[]数组的组合类型是java.lang.String的Class对象。

    访问数组的组合类型的代码如下:

    String[] strings = new String[3];

    Class stringArrayClass = strings.getClass();

    Class stringArrayComponentType = stringArrayClass.getComponentType();

    System.out.println(stringArrayComponentType);

    示例代码将输出"java.lang.String",这是String[]数组的组合类型。

    展开全文
  • =====================================================================================用Java反射来处理数组有时候是技巧性很强的。特别是如果你需要获取一个给定类型的数组的Class对象,像int[ ]等。本文将讲述...
  • 比如说,要反射main,这样写: Method mainMethod = testClass.getMethod("main", new Class[]{String[].class});
  • Java反射访问操作数组

    2021-02-28 15:23:13
    java.lang.reflect 包下提供了一个 Array 类,Array 对象可以代表所有的数组。程序可以通过使用 Array 来动态地创建数组,操作数组元素等。Array 提供了如下几类方法。static Object newInstance(Class> ...
  • 什么是反射反射(Reflection)能够让运行于JVM中的程序检测和修改运行时的行为。”这个概念常常会和内省(Introspection)混淆,以下是这两个术语在Wikipedia中的解释:内省用于在运行时检测某个对象的类型和其包含的...
  • Java反射获取数组参数String...

    千次阅读 2019-04-03 09:50:43
    本质是String[], 在使用反射获取方法的时候需要使用String[].class 调用invoke方法时候需要用Object[] public class A { public void a(String... str) { System.out.println("a"); } //获取反射对象的...
  • Java 数组

    2021-04-22 14:02:14
    Java 数组作者: Jakob Jenkov 译者:叶文海(yewenhai@gmail.com)内容索引java.lang.reflect.Array创建一个数组访问一个数组获取数组的 Class 对象获取数组的成员类型利用反射机制来处理数组会有点棘手。尤其是当你想...
  • Java反射 数组

    2018-03-28 11:16:27
    Java中使用数组反射有时可能有点棘手。 特别是如果您需要获取某个类型的数组的类对象,如int []等。本文将讨论如何通过Java Reflection创建数组并获取其类对象。 ###java.lang.reflect.Array中 通过Java处理数组...
  • java反射处理数组

    2017-10-12 16:35:34
    Java反射中,如果Method的参数里含有数组或者可变参数形式,那么在调用Invoke的时候,稍有点诡异,这里记录一下。可变参数实质就是数组,调用方式和普通数组一样。用反射方式执行某个类中的main方法 public class...
  • 写完善例子,,你看看publicclassTest{publicvoidmethodA(String[]args,Objectobj){System.out.println("数组:"+Arrays.toString(args)+",对象:"+obj);}publicstaticvoidtest(StringclassPath,Objectobj,String...
  • java数组反射

    2021-02-12 14:01:53
    数组反射如果因为某种原因,您并不确定参数或对象是不是数组,您可以检索对象的 Class 对象并询问它。 Class 类的 isArray()方法将会告诉您。一旦您知道拥有了一个数组,您可以询问 Class 的 getComponentType()方法...
  • Java技术对接收数组参数的成员方法进行反射 让初学者更易懂
  • java.lang.reflect.Array类提供了通过静态方法来动态创建和访问Java数组的操作。1.主要的静态方法java.lang.reflect.Array提供以下几类静态方法操作:Array.newInstance() :创建引用类型的数组Array.set()和Array....
  • 希望通过java反射以及泛型来实现动态测试SortClass中的各种排序函数,这时getmethod方法和invoke方法的参数不知道如何解决了。我写的这个实现一直报参数异常代码class SortClass{//选择排序public void selectSo...
  • 利用java反射机制调用一个本身含有数组参数的方法需要一点点技巧。下面的代码展示了怎么样正确地和错误地使用java反射机制调用这样的方法。 –一个含有这种方法的Java类– public class Dao { public ...
  • 利用java反射原理调用方法时,常先需要传入方法参数数组才能取得方法。该方法参数数组采用动态取得的方式比较合适
  • 对于创建非数组实例,可以看这篇文章 : Java反射 - [实例演示] 创建类的对象多种方式 一、创建数组实例 public class ReflectTest{ public static void main(String[] args) { String[] strArr = (String[]) ...
  • 本文实例讲述了Java使用反射操作数组。分享给大家供大家参考,具体如下:一 实战1 代码import java.lang.reflect.*;public class ArrayTest1{public static void main(String args[]){try{// 创建一个元素类型为...
  • java反射机制(含数组参数

    千次阅读 2007-04-14 13:12:00
    java反射是我一直非常喜欢的地方,因为有了这个,可以让程序的灵活性大大的增加,同时通用性也提高了很多。反射原理什么的,我就不想做过大介绍了,网上一搜,就一大把。(下面我是只附录介绍下)////////////////...
  • Java反射数组

    2016-07-14 22:17:04
    java.lang.reflect.ArrayJava反射机制通过java.lang.reflect.Array这个类来处理数组。不要把这个类与Java集合套件中的java.util.Arrays混淆,java.util.Arrays是一个提供了遍历数组,将数组转化为集合等工具方法的类...
  • 要实现一个公共的反射类,具备调用任意方法,并且参数数组。 这样反射与被反射方法,就摆脱了参数数量和类型的束缚。 import java.lang.reflect.Method; import java.util.Arrays; /** * 模块: * MyReflect...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 101,070
精华内容 40,428
关键字:

java反射数组参数

java 订阅