Java中的方法重载是通过改变参数列表中参数的顺序来实现的，那它有什么用呢？

Question

Closed. This question is opinion-based. It is not currently accepting answers.

---

想要改进这个问题？更新问题，以便可以通过编辑这篇文章用事实和引文来回答它。

6 年前已关闭。

Answer 1

(iii)只是(ii)的一个特例。

“int, long, String”和“String, int, long”是 (ii) = 不同的数据类型，但恰好是同一组类型。

但是，混杂的重载会导致代码混乱。

Answer 2

如果您的意图只是参数序列，则方法重载是无用的，因为恕我直言，您只是鼓励样板代码（重复相同的代码），并且如果参数全部具有相同的数据类型，您将收到编译错误，因为该方法签名不明确。

当参数可以作为多种数据类型存在时，为了方便起见，我在 API 中进行了很多方法重载：

public class Client {

   public Status get(String request) {
      return get(new Request(request));
   }

   public Status get(Request request) {
      // do stuff
   }

}

如果您有很多参数，并且其中许多参数是可选的，我建议查看 构建器模式。构建器模式的目的是创建一个由可选参数构造的不可变对象。例如：

public String get(String arg0, String arg1, String arg2) {
   // do stuff
}

public String get(String arg0, String arg1) {
   return method(arg0, arg1, null);
}

public String method(String arg0) {
   return method(arg0, null, null);
}

可以通过构建器进行改进：

class Request {

    final String arg0;
    final String arg1;
    final String arg2;

    private Request(Builder b) {
        this.arg0 = b.arg0;
        this.arg1 = b.arg1;
        this.arg2 = b.arg2;
    }

    // getter methods

    public static class Builder {
        String arg0, arg1, arg2;

        public Builder arg0(String arg) {
            this.arg0 = arg;
            return this;
        }

        public Builder arg1(String arg) {
            this.arg1 = arg;
            return this;
        }

        public Builder arg2(String arg) {
            this.arg2 = arg;
            return this;
        }

        public Request build() {
            return new Request(this);
        }

    }

}

class Client {
    public String get(Request request) { }
}

new Client().get(Request.Builder().arg0("arg0").arg1("arg1").arg2("arg2").build());

我经常做的另一个重载是方法可以接受不同数据类型的参数：

public String lookup(String variant) {
   return lookup(Integer.parseInt(variant));
}

public String lookup(int ordinal) {
   // logic
}

Answer 3

啊!有道理！我的想法是 -

public String buildUrl(String protocol, String host, int port){
    return protocol + "://" + host + ":" + port;
}

public String buildUrl(String protocol, int port, String host){
    return protocol + "://" + host + ":" + port;
}

所以，我认为这是没有用的。但可能存在这样的情况（花了很长时间才想出来:-)） -

public int countTotalTruckWheels(boolean hasSpare, int numberOfTrucks){
    if(hasSpare){
        return (numberOfTrucks+1)*4;
    } else{
        return numberOfTrucks*4;
    }
}

public int countTotalTruckWheels(int numberOfAxlesInTruck, boolean strongAxle){
    if(strongAxle){
        //each axle can hold 4 wheels
        return numberOfAxlesInTruck*4;
    } else {
        return numberOfAxlesInTruck*2;
    }
}

这里参数的数据类型不仅仅是重新排序，而且参数的整个含义已经改变。

我根据上面的许多答案理解了这一点。我无法选择一个特定的答案。另外，我想将其添加为评论，但它太大了，无法成为评论。因此在这里添加了它。

Answer 4

它还说参数列表可能有所不同
（三）。参数顺序

(iii) 是完全错误的。您不能通过简单地更改参数的顺序来更改重载。举个例子：

int add(int x, int y)
int add(int y, int x)

这不是合法的重载。现在考虑这个例子：

int fill(int number, char c)
int fill(char c, int number)

记住参数名称并不重要，所以实际上，对于编译器来说它看起来像这样：

int pad(int, char)
int pad(char, int)

这是有效的重载，但不是因为你改变了参数的顺序，而是因为一个或多个参数的类型发生了变化。这两种方法有所不同，因为方法之间的第一个参数的类型不同（第二个参数的类型也是如此）。

---

仅通过更改参数顺序来尝试重载方法有什么用？

没有用。文本不说您“应该”通过更改参数序列来进行方法重载，文本只是说它是可能的（只要重新排序创建唯一的参数签名）。这只是重载工作原理的结果（副作用）——我可以肯定地说，这不是语言设计者试图支持的用例。换句话说：

仅仅因为您可以做到这一点，并不意味着您应该。

Answer 5

进行这种超载的理由并不多，但我能想到几个。

您的 API 公开，并且除了相当常见（但未继承）的方法之外的所有方法签名都是相同的。假设它们都是 myFunct(String,int) ，其中之一碰巧是 myFunct(int,String) 。您将希望保留该函数以实现向后兼容性，但您也可能使该类也具有 myFunct(String,int) 以保持一致。

另一个原因（即使它是一个糟糕的）是你可能会让人们以一种顺序习惯它们，可能来自不同的图书馆，或者可能他们只是有诵读困难......但是如果它是，你可能会重载它来交换参数这样做方便。显然，这可能很棘手，因为如果您有 (String,int,int) 您可能也不想执行 (int,int,String) 或 (int,String,int) 。最好只保留一个。

Answer 6

你是对的，iii 通常不会提出强有力的案例。通常，有必要保持强类型化，如下所示

void save(String key, int value);
void save(String key, float value);
void save(String key, byte value);

等。

Answer 7

这似乎有点毫无意义，在很多情况下，我可以理解为什么有些人可能只是简单地打乱参数序列以支持重载，而实际上他们只是设计得很糟糕的代码。然而，在某些情况下它是完全有道理的。

大多数程序员会选择某些参数序列，因为这些参数在特定顺序中更有意义，或者因为顺序实际上对某些计算的结果至关重要。以这些重载方法为例：

int raise(int i, String n);
int raise(String i, int n);

正如您在数学课上很早就学到的那样，用一个值求另一个值是一种非交换运算（即 2^3 != 3^2）。

因此，在这个例子中，每个方法都会通过另一个方法来提高一些数值。第一个参数始终是要由第二个参数给出的值引发的值（顺序很重要）。但是，正如您所看到的，参数列表的每个参数都可以由 String 或 int 类型表示。然而，操作的语义保持不变。

raise("12", 2);
raise(12, "2");

当然，出于显而易见的原因，这是一个非常人为的示例，但您可以看到原则上它是合理的。

我确信如果我多给它一点，我可以想出一个更好的例子，其中参数是某种特殊类型，这种事情更有意义。

Answer 8

参数列表由参数的数量和类型决定。因此，如果您的参数具有不同的类型，则对参数重新排序会产生不同的重载，因为编译器会在不同的槽中看到不同的类型。

f(int a, String b)

f(String b, int a)

这两个函数都有两个参数，但类型不匹配，因此它们是有效的重载。

至于为什么要这样做，通常情况下参数的顺序很重要。在我维护的代码库中，我们有一些异常，这些异常可能有原因、消息和其他参数。所以下面的两个调用是不一样的：

Exception cause;
String msgFormat = "An error occurred while processing {0}";
String recordName = "abc123";

throw new ABCException(cause, message, recordName);

throw new ABCException(message, cause, recordName);

throw new ABCException(message, recordName);

throw new ABCException(recordName, message);

第一种情况cause是异常的原因，message是要显示的消息，而record 是消息的参数。在第二种情况下，cause 和 recordName 都被解释为消息的参数。在第三种情况下，没有原因，在第四种情况下，没有原因，而且 message 参数处于错误的位置，并且不会被正确处理。

这是通过对 ABCException 构造函数进行几个有用的重载来实现的（尽管在本例中我们使用可变参数来支持无限数量的参数）。