在java中只调用一次相同的方法

Question

我有四个不同的类 classA、classB、classC 和 classD。所有四个类都有相同的静态方法 search()，它接受两个字符串参数。如果我想一次在主类的四个不同类中调用静态方法搜索。我怎样才能做到这一点。现在我的主类代码如下。我还需要对其他 3 个类执行相同的操作。我怎样才能做到这一点，并以与 classA 相同的方式显示其他 3 的结果。搜索的方式在 4 个不同的类中完成，但它们应该给出相同的结果。

Main() {

    Object[] zy;

    for (String pattern : Read.arrayList) {
        List<Integer> results = ClassA.findAll(pattern, dataToSearch);
        zy = results.toArray();
        for (int i = 0; i < zy.length; i++) {
            System.out.println(" Pattern searched " + pattern + " match is found at index : "+ results);
        }
    }
    if (zy.length == 0) {
        System.out.println("Nothing matched");
    }
}

Answer 1

我强烈建议您将其更改为非静态方法。看看分离界面是多么简单和美好：

public interface Common {
    List<Integer> findAll(String pattern, String dataToSearch);
}

public class A implements Common ...
public class B implements Common ...
public class C implements Common ...
public class D implements Common ...

// in main:
List<Common> allYourClasses = new ArrayList<Common>();
allYourClasses.add(new A());
allYourClasses.add(new B());
allYourClasses.add(new C());
allYourClasses.add(new D());

List<Integer> result = new ArrayList<Integer>();
for (Common c : allYourClasses) {
    result.addAll(c.findAll(pattern, dataToSearch));
}

Answer 2

1 - 你不应该这样做。避免使用静态方法。原因之一是没有确切的类就不能调用它们。一组实现简单接口的类将在各个方面更快、更安全、更好地工作

2 - 你可以（但你不应该）做这样的事情：

    for (Class<?> clazz : new Class[] { ClassA.class, ClassB.class,
            ClassC.class }) {

        Object[] zy = null;
        String dataToSearch = "";
        String[] arrayList = { "a" };
        for (String pattern : arrayList) {

            List<Integer> results = findAllForClass(clazz, pattern,
                    dataToSearch);
            zy = results.toArray();
            for (int i = 0; i < zy.length; i++) {
                System.out.println(" Pattern searched " + pattern
                        + " match is found at index : " + results);
            }
        }
        if (zy.length == 0) {
            System.out.println("Nothing matched");
        }
    }

@SuppressWarnings("unchecked")
public static List<Integer> findAllForClass(Class<?> clazz, String pattern,
        String dataToSearch) {
    List<Integer> list = null;
    try {
        list = (List<Integer>) clazz.getDeclaredMethod("findAll", String.class,
                String.class).invoke(null, pattern, dataToSearch);
    } catch (Exception e) {
        list = Collections.emptyList();
    }
    return list;
}

你看到@supresswarning 和 try/catch 了吗？好吧，这是一个提示：告诉你这段代码至少是可疑的。它实际上是不安全的、性能不佳的，而且是一种愚蠢的解决方法。

（但我们一生中都做过一次这样的事情）

Answer 3

我真的不明白为什么有人会这样做。

也就是说，您可以有一个方法以 Class 作为参数并通过名称显式调用该方法 (getMethod.../invoke())。

这会让你回到非静态世界，你可以迭代你想要调用的类。 （但同样，为什么首先使用静态？）

伪未经测试的代码：

public void invokeStatic(Class clazz, String method, Class<?> paramsTypes[], Object[] params) {
    Method method = clazz.getMethod(method, paramsType);
    method.invoke(params);
}

Answer 4

如果您想将所有结果组合在一起，只需将结果添加到您的列表中即可：

List<Integer> results = ClassA.findAll(pattern, dataToSearch);
results.addAll(ClassB.findAll(pattern, dataToSearch));
// etc.