Java reflection, call method of the passed in object's class

Question

Just start to learn and know about java reflection, would appreciate any help on this problem.

I'm trying to write a method and it looks like this:

    private <T> void myMethod (List<T> testSub) {
        testSub.forEach(s -> assertEquals(s.getSource(), "TEST"));
    }

But it shows an error because java don't know if testSub's class has getSource() this method and it want me to cast s.getSource() to a known class.

What I want is to somehow let java know that the the itmes in testSub's class has this getSource() method and it could be invoked and safe to call.

Thanks in advance!

----------------------------Update---------------------- Choose to use this way:

    private <T> void myMethod (List<T> testSub, Class<T> clazz) {

        testSub.forEach(s -> assertEquals(clazz.getMethod("getSource").invok(s), "TEST"));
    }

Has to Catch exceptions in for it but works.

Answer 1

Add a bound to your type variable definition:

private <T extends HasSource> void myMethod (List<T> testSub) {

where HasSource defines getSource() method:

public interface HasSource {
    String getSource()
}

The compiler will know that T is actually a subclass of HasSource and hence that it has getSource() method.

Of course, to leverage this solution, you would need to make all the classes you want to use as elements of testSub implement that HasSource interface.

Answer 2

There are two ways that you can call the getSource() method.

One is the normal method call expression like object.getSource(). That's only possible if the compiler knows that object is of a class that has a getSource() method.

In your case, the compiler only knows s to be of the generic type T, which is unbounded, so can be any class, even Object, and the compiler can't confirm that there is a getSource() method.

If you don't have a common parent class or interface for your list elements having the getSource() method, you could go for instanceof / cast combinations. That's ugly but might work for you if you really know the possible element classes.

for (T s : testSub) {
    if (s instanceof Class1) {
        assertEquals(((Class1) s).getSource(), "TEST"));
    } else if (s instanceof Class2) {
        assertEquals(((Class2) s).getSource(), "TEST"));
    } else {
        throw new IllegalArgumentException();
    }
}

The other way is using reflection. You could locate the Method m = s.getClass.getMethod("getSource") and, if not null, do m.invoke(s). But that's even uglier than the instanceof / cast solution, and surely a lot slower.