从.class调用对象的 toString（） 方法（类<？>）

Question

我有一个名为“Test”的类，我正在将其传递给一个方法，该方法的类型为。Test.classClass<T> clazz我需要从该 clazz 变量调用类 Test 的 toString（） 方法。我们可以使用反射来做到这一点，而不会对测试进行类型转换吗？

Answer 1

首先从 clazz 变量创建对象，然后调用该对象的方法。toString()

clazz.newInstance().toString();

如果你有一个默认的构造函数，那么它也可以工作：

clazz.getConstructor().newInstance().toString();

更新：如果你想做一般的测试函数，那么你必须实现这样的测试函数。

public void TestToString(Object obj,String expectedVal){
    assertEquals(obj.toString(),expectedVal);
  }

Answer 2

不能对参数调用方法。这只是类的描述，但要调用方法，您需要实例化该类。
您可以：
- 使用反射创建.class参数的实例以调用该方法
，或者
- 使用反射来调用实例上的方法。Class

但底线是，你需要一个实例。

还有一点评论（正如Joachim Sauer已经说过的那样）：
方法存在于类上，并且所有内容都扩展了类，因此它始终可用。
不需要反射，泛型或转换。您只需在类中重写此方法即可。toString()ObjectObject

一个小例子来演示调用String（）的不同方法：

public class Test {

    private String name = "unnamed";

    public Test() {}

    public Test(String name) {

        this.name = name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String toString() {

        return name;

    }

    public static <T> T doReflectionCreateToString(Class<T> clazz) {

        try {

            T newT = clazz.getConstructor(String.class).newInstance("Name 2");

            System.out.println("Created by reflection:    "+ newT);

            return newT;

        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException

                | NoSuchMethodException | SecurityException e) {

            e.printStackTrace();

        }

        return null;

    }

    @SuppressWarnings("unchecked")

    public static <T, E> E doReflectionCall(T obj, String methodName, Object[] arguments, Class<E> returnClazz) {

        try {

            Class<?> clazz = obj.getClass();

            Method myMethod = clazz.getDeclaredMethod(methodName);

            return (E) myMethod.invoke(obj, arguments);

        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {

            e.printStackTrace();

        }

        return null;

    }

    public static <T> void doGenericToString(T obj) {

        System.out.println("toString by Generic way:  "+ obj);

    }

    public static void main(String[] args) {

        Test t = new Test();

        t.setName("Name 1");

        System.out.println("toString by standard way: "+ t);

        doGenericToString(t);

        System.out.println("Called by reflection:     "+ doReflectionCall(t, "toString", new Object[]{}, String.class));

        Test newT = doReflectionCreateToString(Test.class);

        System.out.println("Returned by reflection:   "+ newT);

    }

}

哪些输出：

按标准方式 toString： 名称 1
to按通用方式排列： 名称 1
由反射调用： 名称 1
由反射创建： 名称 2
由反射返回： 名称 2

如您所见，无论是通过标准方式还是通过泛型或更糟糕的反射，都会导致相同的逻辑。
我希望这能启发你（和其他人）;)