GetMethod(...) and polymorphism

Question

Hi,
When trying to get a method by specifying not the formal parameter classes, but subclasses of it, one gets NoSuchMethodException. E.g. the add(Object) method from Collection doesn't work when one specifies Color in stead of Object as argument type.
Is the only option to write code which tries all combinations of superclasses of all arguments, or are there better solutions?
BA

Answer 1

I had a bit of fun once writing something to mimic the compiler's method binding. The documentation explains that it isn't perfect, but if you really want to hack it, feel free. I'll make it publicly available with a request that anyone who modifies it to fix the current limitations post their fix here. package com.akshor.pjt33.utils;
import java.lang.reflect.*;
* A non-instantiable class providing static utility methods related to
* reflection.
* @specifier Peter Taylor
* @implementer Peter Taylor
public abstract class ReflectionUtils
     * This constructor cannot be called, as it prevents subclassing.
    private ReflectionUtils()
        throw new UnknownError();
     * Simulates the compile-time binding of a method-name and a list of
     * parameter types. Whereas <code>Class.getMethod(String, Class[])</code>
     * looks for methods with the exact signature, this looks through all the
     * applicable public methods of the specified class, and selects the most
     * specific.
     * <p>
     * Note that this method will currently throw an exception if there is more
     * than one maximally specific method, even if they all have the same
     * signature. This is not quite the same as the JLS 15.12.2.2. Consider the
     * case <pre>
     *     public interface A { public void method(); }
     *     public interface B { public void method(); }
     *     public abstract class C implements A, B { }
     *     getMethod(C, "method", new Class[0]);</pre>
     * @param clazz The class in which to seek the specified method.
     * @param methodName The name of the method to seek.
     * @param paramTypes The list of parameters.
     * @return The unique maximally specific method with respect to the
     *         specified class, name and parameter types.
     * @throws NoSuchMethodException if there isn't a unique maximally specific
     *                               method, or if the name is "&lt ;init&gt ;" or
     *                               "&lt ;clinit&gt ;". (Off to file bug about JDCF
     *                               handling of HTML entities in tags).
* @throws IllegalArgumentException if any argument is null.
* @throws SecurityException if access to the information is denied.
* @see Class#getMethods()
public static Method getMethod(Class clazz,
String methodName,
Class[] paramTypes)
throws NoSuchMethodException
// Check the arguments are all non-null.
if (clazz == null || methodName == null || paramTypes == null)
throw new IllegalArgumentException();
// We don't need to check for <init> and <clinit>, because they're not
// in the list of methods returned.
// Since we assume a unique maximally specific method, we don't need to
// store a Set of maximally specific methods.
Method currentBestCandidate = null;
// Iterate through the public methods of the class.
Method[] candidates = clazz.getMethods();
for (int i = 0; i < candidates.length; i++)
// We discard non-applicable methods immediately.
if (methodApplicable(candidates, methodName, paramTypes))
// If the method is applicable, there are four cases:
// 1. currentBestCandidate is null. Store candidates[i] there.
// 2. currentBestCandidate is more specific than candidates[i].
// Discard candidates[i].
// 3. candidates[i] is more specific than currentBestCandidate.
// Store it there.
// 4. Neither candidates[i] nor currentBestCandidate is more
// specific than the other. Throw an exception.
// (Note: the JLS solution would be to case-split again: if
// both are concrete, throw the exception; if one is
// concrete, select that one; if both are abstract, pick one
// arbitrarily. However, in the latter case we really want a
// new Method whose thrown checked exceptions are formed by
// intersection of the thrown checked exceptions of the two
// abstract methods - and since Method doesn't provide any
// protected or public constructors, we can't provide such a
// Method. This is why we throw an exception).
if (currentBestCandidate == null ||
methodMoreSpecific(candidates[i], currentBestCandidate))
// candidates[i] is the new current best candidate.
currentBestCandidate = candidates[i];
else if (!methodMoreSpecific(currentBestCandidate,
candidates[i]))
// Neither method is more specific than the other.
throw new NoSuchMethodException("Ambiguity");
// If we have a best candidate, that's the method to return.
if (currentBestCandidate != null)
return currentBestCandidate;
// No such method found. Pity.
throw new NoSuchMethodException("No applicable public method");
* Checks whether or not a method is applicable to a method call. This is so
* iff the name is correct, the number of parameters is correct, and each of
* the call's parameter types is assignable to the method's corresponding
* parameter type.
* @param m The method to check for applicability.
* @param name The required method name.
* @param paramTypes The required parameter types.
* @return Whether or not the method is applicable to the name and parameter
* types.
* @throws IllegalArgumentException if any parameter is null.
private static boolean methodApplicable(Method m,
String name,
Class[] paramTypes)
// Check the parameters are non-null.
if (m == null || name == null || paramTypes == null)
throw new IllegalArgumentException();
// Check that the name corresponds.
if (!m.getName().equals(name))
return false;
// Get the parameter types of the method, and check that the number of
// parameters corresponds.
Class[] actualParamTypes = m.getParameterTypes();
if (actualParamTypes.length != paramTypes.length)
return false;
// Check that all of the parameter types are assignable.
for (int i = 0; i < paramTypes.length; i++)
if (!actualParamTypes[i].isAssignableFrom(paramTypes[i]))
return false;
// All tests pass.
return true;
* Checks whether or not the first parameter is more specific than the
* second parameter. This is the case iff the declaring class of
* <code>more</code> is assignable to the declaring class of
*<code>less</code> and each of the parameters of <code>more</code> is
* assignable to the corresponding parameter of <code>less</code>. (The
* observant will notice that the test is a &ge; rather than a > test).
* @param more The method to check for being more specific.
* @param less The method to check for being less specific.
* @return Whether or not <code>more</code> is more specific than
* <code>less</code>.
* @throws IllegalArgumentException if either parameter is null, or if they
* have different names or numbers of
* parameters.
private static boolean methodMoreSpecific(Method more, Method less)
// Check that both of the parameters are non-null.
if (more == null || less == null)
throw new IllegalArgumentException("Null parameter");
// Check that they have the same names.
if (!more.getName().equals(less.getName()))
throw new IllegalArgumentException("Different names");
// Get their parameter types and check that they have the same number of
// parameters.
Class[] moreParamTypes = more.getParameterTypes();
Class[] lessParamTypes = less.getParameterTypes();
if (moreParamTypes.length != lessParamTypes.length)
throw new IllegalArgumentException("Different numbers of params");
// To be more specific, more needs to have a declaring class assignable
// to that of less.
if (!less.getDeclaringClass().isAssignableFrom(
more.getDeclaringClass()))
return false;
// To be more specific, more has to have parameters assignable to the
// corresponding parameters of less.
for (int i = 0; i < moreParamTypes.length; i++)
if (!lessParamTypes[i].isAssignableFrom(moreParamTypes[i]))
return false;
// All tests passed.
return true;