Question

我对java＆amp; s相对缺乏经验仿制药，如果这是一个愚蠢的问题，请原谅。

我有3个非常相似的辅助方法，名为verifyTextualSort，verifyNumericSort和verifyDateSort。

这3种方法遵循相同的模式，只是略有不同：

private boolean verifyTextualSort(...) {

    ArrayList<String> list = new ArrayList<String>();

    // Do common stuff with the list

    // Do textual-specific stuff 

    // Do common stuff with the list

}

private boolean verifyNumericSort(...) {

    ArrayList<Integer> list = new ArrayList<Integer>();

    // Do common stuff with the list

    // Do Numeric-specific stuff

    // Do common stuff with the list

}

有没有什么方法可以将它们组合成一个方法，以某种方式传递类型（Integer，String，Date）作为参数？我必须能够知道方法内部的类型，以便我可以做正确的具体事情。

Answer 1

特定的东西需要三种方法。但是对于常见的东西，你可以创建一个他们都会调用的常用方法。

private boolean verifyNumericSort(...) {
    List<Integer> list = new ArrayList<Integer>();

    commonStuff1(list);

    // Do Numeric-specific stuff

    commonStuff2(list);
}

Answer 2

您可以传递Class作为参数，如果这是你想要的（如你所说，将类型作为参数传递）：

public <T> void test(List<T> l, T t, Class<T> c) {
    System.out.println(c.getName());
    System.out.println(l.get(0).getClass().getName());
    System.out.println(t.getClass().getName());
}

上面的所有系统输出都会打印出该类的名称，因此您可以选择哪一个最适合您。

Answer 3

由于type erasure，你不能通过内省使用泛型来做到这一点。但是如果列表不为空，则可以检查第一个元素的类型，然后调用适当的方法。

Answer 4

因为你有3个字段，你可以这样做..

class A
{
private Date date = null;
private Integer int = null;
private String text = null;

//add getters and setters for these fields
}

现在传递这个类Object作为该方法的争论

public boolean verify(A a){
a.getDate();
a.getInt()
//etc and do your stuff
}

Answer 5

您需要泛型和重构：

private boolean verifyTextualSort(List<String> strings) {
    commonStuffA(strings);
    // Do textual-specific stuff
    commonStuffB(strings);
    return true; // ?
}

private boolean verifyNumericSort(List<Integer> ints) {
    commonStuffB(ints);
    // Do Numeric-specific stuff
    commonStuffB(ints);
    return true; // ?
}

private void commonStuffA(List<?> things) { // This method accept a list of anything
    // Do common stuff A with the list
}

private void commonStuffB(List<?> things) { // This method accept a list of anything
    // Do common stuff B with the list
}

private void someCallingMethod() {
    List<String> strings = new ArrayList<String>();
    verifyTextualSort(strings);

    List<Integer> ints = new ArrayList<Integer>();
    verifyTextualSort(ints);
}

Answer 6

我认为你可能会做类似的事情：

  public <T extends Object> boolean verify(T t)
  {
    if(!(t==null))
    {
      if(t instanceof Date)
      {
        //Do date verify routine
        return true;
      }
      else if(t instanceof String)
      {
        //Do String verify routine
        return true;
      }
      else
      {
        //Do default verify routine which could be Integer
        return true;
      }
    }
    return false;
  }

注意：这未经过测试。

Answer 7

正如其他人所提到的那样，由于类型擦除，你不能用泛型做到这一点（请参阅其他答案以获得类型擦除的链接）。我相信你可以通过多态得到一个合理的解决方案（没有 instanceof ）。这是一个例子：

public class VerifySort
{
    public static void main(String[] args)
    {
        VerifySort verifySort = new VerifySort();

        Date testDate = new Date();
        Integer testInteger = 17;
        String testString = "Blammy";

        verifySort.verify(testString);
        verifySort.verify(testInteger);
        verifySort.verify(testDate);
    }

    private boolean verify(Date parameter)
    {
        SimpleDateFormat dateFormat = new SimpleDateFormat();
        System.out.print("Date parameter: ");
        System.out.println(dateFormat.format(parameter));

        return true;
    }

    private boolean verify(Integer parameter)
    {
        System.out.print("Integer parameter: ");
        System.out.println(parameter);

        return true;
    }

    private boolean verify(String parameter)
    {
        System.out.print("String parameter: ");
        System.out.println(parameter);

        return true;
    }

如何将具有不同参数类型的三个类似方法合并为一个通用类型？

7 个答案: