1

我有两个接口结构。

我的界面1

public interface MyInterface1{

public Object SUM(Object O,Object P);

}

我的界面2

public interface MyInterface2{

public int SUM(int O,int P);
public double SUM(int O,double P);
public double SUM(double O,double P);
public double SUM(double O,int P);

}

哪个是更好的设计方法来实现接口以保持代码效率？

4

6 回答 6

6

第二种方法（重载）更受欢迎，因为它包含强类型的方法签名。

想想下面的代码。

public class InterfaceImpl implements MyInterface2{

    public Object SUM(Object O,Object P){
        //Really what can I do here without casting?

        /* If I have to cast, I might as well define
         types in the method signature, guaranteeing
         the type of the arguments
        */

       //Lets cast anyway
       return (Integer) O + (Integer) P;
    }

    public static void main(String[] args) throws ParseException {
       System.out.println(SUM(1,2));  //Excellent Returns 3
       //Yikes, valid arguments but implementation does not handle these
       System.out.println(SUM(true,false)); //Class cast exception          
    }
}

结论

随着遇到该方法需要处理的更多类型，实现将被迫在进行必要的转换之前执行类型检查。理论上，每个扩展 Object 的类都需要进行类型检查，因为方法签名只限制类型的参数。由于参数是对象，因此要检查的类型数量是无限的，这是不可能的。

通过使用重载方法，您可以表达方法的意图并限制允许的类型集。这使得编写方法的实现变得更加容易和易于管理，因为参数将是强类型的。

于 2013-04-10T09:34:25.033 回答
2

正如已经提到的其他答案，重载更好。

但我还要补充一点，你不需要 4 个版本，只需要 2 个：

public interface MyInterface2 {
  public int SUM(int O, int P);
  public double SUM(double O, double P);
}

如果您SUM使用 (int,double) 或 (double,int) 调用，则 int 将向上转换为 double，而第二个方法将运行。

例如，下面的代码编译并打印“goodbye”：

public class Test implements MyInterface2 {
  public int SUM(int o, int p) {
    System.err.println("hello");
    return o + p;
  }

  public double SUM(double o, double p) {
    System.err.println("goodbye");
    return o + p;
  }

  public static void main(String[] arg) {
    Test t = new Test();
    t.SUM(1.0, 2);
  }
}
于 2013-04-10T09:38:35.063 回答
1

在这种情况下，第二个选项很好。但它因代码而异。例子

interface InterfaceFrequencyCounter
{
    int getCount(List list, String name);
}

interface AnotherInterfaceFrequencyCounter
{
    int getCount(ArrayList arrayList, String name);
    int getCount(LinkedList linkedList, String name);
    int getCount(Vector vector, String name);
}

所以现在在上面给定的情况下，第二种选择不是好的做法。第一个很好。

于 2013-04-10T09:43:33.427 回答
0

重载更好，因为您不希望有人用 aString或其他东西称呼您的方法。

你可以做的是，如果你有一个普通的超类（Number在你的情况下——如果你也想得到 Long 和 Float）。

于 2013-04-10T09:33:20.483 回答
0

对于安全代码方法重载更好的方法。

于 2013-04-10T09:33:45.893 回答
0

如上所述，重载更好。

如果您遇到 AmitG 描述的情况，您应该使用接口，而不仅仅是最通用的对象类型。无论如何，您的方法几乎总是可以仅适用于对象的一部分子集，而不是所有对象。在这种情况下，您需要找到一个通用接口并在方法签名中使用它，就像 AmitG 在他的示例中所做的那样。接口的使用清楚地显示了您对方法客户的意图，它是类型安全的，并且无需在方法内部进行强制转换。

于 2013-04-11T07:30:01.817 回答