Question

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

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.

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

4 个答案: