Java 不考虑参数的获取方法

我正在尝试获取该方法，而不管该方法采用什么参数（到目前为止，还没有方法重载，将来也不会）。我能想出的唯一可能的解决办法是

private Method getMethod(Class<?> clas, String methodName) {
    try {
        Method[] methods = clas.getMethods();
        for (Method method : methods) {
            if (method.getName().equalsIgnoreCase(methodName)) {
                return method;
            }
        }
    } catch (SecurityException e) {
        e.printStackTrace();
    }
    return null;
}

私有方法getMethod（类clas，字符串methodName）{
试一试{
Method[]methods=clas.getMethods（）；
用于（方法：方法）{
if（method.getName（）.equalsIgnoreCase（methodName））{
返回法；
}
}
}捕获（安全异常e）{
e、 printStackTrace（）；
}
返回null；
}

我想问的是，有没有一种方法可以获取一个方法，而不管它的参数是什么？我正在查看

clas.getMethod（“methodName”，parameters）

，如果我在其中提供

null

，它将尝试获取一个没有参数的方法。这是不可能的

有什么想法吗

编辑

---

谢谢大家的意见。在我的例子中，我知道不管情况如何，只有一种方法。我之所以使用

ignoreCase

，是因为输入将来自开发人员（在其他团队中），他将以硬编码字符串的形式提供名称。因此，为了防止事情从我们手中溢出，我使用了一种安全的方法

不，你这样做才是最好的选择。方法由其签名标识，签名包括名称和参数类型。

以下是一个解决方案，它检索具有指定类和方法名称的所有方法，而不考虑方法的参数：

public class Test
{
    private class Foo
    {
        public void bar()
        {

        }

        public void bar(String s)
        {

        }

        public void goo()
        {

        }
    }

    private static Method[] getMethods(Class<?> clazz, String methodName)
    {
        List<Method> methods = new ArrayList<Method>();

        Method[] declaredMethods = clazz.getDeclaredMethods();

        for (Method declaredMethod: declaredMethods)
        {
            if (declaredMethod.getName().equals(methodName))
            {
                methods.add(declaredMethod);
            }
        }

        return methods.toArray(new Method[methods.size()]);
    }

    public static void main(String[] args)
    {
        Method[] methods = getMethods(Foo.class, "bar");

        System.out.println(Arrays.toString(methods));
    }
}

---

你做得很好。这与我四年前处理的一个类似问题的解决方案基本相同，即创建一种在Java中创建回调方法的方法。我的

回调

类的构造函数是：

public Callback(Class<?> clazz, String methodName, Object parentObj) {
    // Find a method with the matching name
    Method[] allMethods;
    try { allMethods = clazz.getMethods(); }
    catch(SecurityException se) { allMethods = new Method[0]; }

    int count = 0;
    Method single = null;
    for(Method m : allMethods) {
        if(m.getName().equals(methodName)) {
            single = m;
            count++;
        }

        // Can't have more than one instance
        if(count > 1)
            throw new IllegalArgumentException(clazz.getName()
                + " has more than one method named " + methodName);
    }
    if(count == 0) // No instances found
        throw new IllegalArgumentException(clazz.getName()
            + " has no method named " + methodName);

    this.parentObj = parentObj;
    this.method = single;
    this.parameters = single.getParameterTypes();
}

public Callback(
    Class<?> clazz,
    String methodName,
    Object parentObj,
    Class<?>...parameters)
{
    try { this.method = clazz.getMethod(methodName, parameters); }
    catch(NoSuchMethodException nsme) { nsme.printStackTrace(); }
    catch(SecurityException se) { se.printStackTrace(); }

    this.parentObj = parentObj;
    this.parameters = parameters;
}

公共回调（类clazz、字符串methodName、对象parentObj）{
//查找具有匹配名称的方法
方法[]所有方法；
试试{allMethods=clazz.getMethods（）；}
catch（SecurityException se）{allMethods=新方法[0]；}
整数计数=0；
方法single=null；
对于（方法m：所有方法）{
if（m.getName（）.equals（methodName））{
单个=m；
计数++；
}
//不能有多个实例
如果（计数>1）
抛出新的IllegalArgumentException（clazz.getName（）
+“有多个名为“+methodName”的方法）；
}
if（count==0）//未找到任何实例
抛出新的IllegalArgumentException（clazz.getName（）
+“没有名为“+methodName”的方法）；
this.parentObj=parentObj；
此方法=单一；
this.parameters=single.getParameterTypes（）；
}
公开回调(
课堂上，
字符串methodName，
对象parentObj，
类…参数）
{
试试{this.method=clazz.getMethod（methodName，parameters）；}
catch（NoSuchMethodException nsme）{nsme.printStackTrace（）；}
catch（SecurityException se）{se.printStackTrace（）；}
this.parentObj=parentObj；
此参数=参数；
}

我的

Callback

类在Java8时代不再真正有用，但当时Java中唯一真正的“回调”方法是匿名接口实现，这对于我的用例来说是不够的

---

正如您在第一个构造函数中看到的，如果发现多个同名方法，它会抛出异常。

使用java streams，有一个非常短的方法可以找到一个方法，第一个匹配，仅通过其名称：

Stream.of(type.getMethods())
.filter((m) -> m.getName().equals(searchedName))
.findFirst()
.get();

---

在这种情况下，我认为这是一个简短且可读的可能性。

我认为您的方法看起来是正确的，除了

equalsIgnoreCase

看起来很奇怪，因为case在Java方法名称中很重要，但可能这正是您需要的。无论如何，我认为没有其他方法可以做到这一点，只能使用

getMethods

或

getDeclaredMethods

搜索自己。如果可以使用Java 8，则有些流函数可以找到匹配项，但本质上是一样的。大小写与参数类型一样重要。谢谢。更新了我的问题以解释我使用equalignorecaseNo问题的原因，我认为这可能与用户输入有关。在这种情况下，您肯定需要自己进行搜索，因为Java不提供任何按名称查找标识符的方法，除非使用精确的、区分大小写的匹配。

Stream.of(type.getMethods())
.filter((m) -> m.getName().equals(searchedName))
.findFirst()
.get();