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

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

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"); 
    } 
}

来源

2011-10-06 Xyz Xyz

是否有一个特定的原因，方法必须是静态的？这似乎是接口方法的一个好选择。 – StriplingWarrior

同意。 [战略模式]（http://en.wikipedia.org/wiki/Strategy_pattern）是这里的一种方式。 –

我强烈建议您将其更改为非静态方法。看看你是多么容易和美好的时候你会分开一个接口：

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)); 
}

来源

2011-10-06 20:16:34 smas

我真的不知道为什么有人会这样做。这就是说，你可以有一个方法将一个Class作为参数，并通过名字（getMethod .../invoke（））明确地调用方法。

这让你回到非静态世界，你可以遍历你想要调用的类。如果您希望将所有的结果一起

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

来源

2011-10-06 20:18:42 ptyx

-2

，只是不断加入结果列表：：（但同样，为什么首先使用静态？）

伪未经测试的代码

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

来源

2011-10-06 20:21:51

如果找到了模式的第一个匹配项，它将A类和B类的结果放在一起。然后，如果发现其他模式匹配，它再次将A类和B类的结果一起给出。有没有办法让我可以一起打印A级的所有结果，然后是B级等？ –

@Xyz Xyz，看看我的答案：它将为A B C和D调用findAll，所有匹配都会放入最终结果列表中。因此，在循环之后，您将得到由A，B，C或D创建的所有Integers – smas

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？好吧，这是一个提示：告诉你，这个代码至少是可疑的。它实际上是不安全的，性能不佳，而且是一个愚蠢的解决方法。

（但我们都在我们的生活中做过这样的事情）

来源

2011-10-06 20:59:36

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

回答

相关问题