Java中的重载

重载允许不同的方法具有相同的名称，但不同的签名，其中签名可能因输入参数的数量或输入参数的类型或两者而异。重载与编译时（或静态）多态性有关。

// Java program to demonstrate working of method
// overloading in Java.
  
public class Sum {
  
    // Overloaded sum(). This sum takes two int parameters
    public int sum(int x, int y)
    {
        return (x + y);
    }
  
    // Overloaded sum(). This sum takes three int parameters
    public int sum(int x, int y, int z)
    {
        return (x + y + z);
    }
  
    // Overloaded sum(). This sum takes two double parameters
    public double sum(double x, double y)
    {
        return (x + y);
    }
  
    // Driver code
    public static void main(String args[])
    {
        Sum s = new Sum();
        System.out.println(s.sum(10, 20));
        System.out.println(s.sum(10, 20, 30));
        System.out.println(s.sum(10.5, 20.5));
    }
}

输出：

30
60
31.0

问题出现：
问：如果确切的原型与参数不匹配怎么办。
答。
优先考虑，编译器采取以下步骤：

类型转换，但转换为同一家族中的更高类型（就范围而言）。
类型转换到下一个更高的家族（假设如果没有可用于 int 数据类型的 long 数据类型，那么它将搜索 float 数据类型）。

让我们举个例子来明确这个概念：-

class Demo {
    public void show(int x)
    {
        System.out.println("In int" + x);
    }
    public void show(String s)
    {
        System.out.println("In String" + s);
    }
    public void show(byte b)
    {
        System.out.println("In byte" + b);
    }
}
class UseDemo {
    public static void main(String[] args)
    {
        byte a = 25;
        Demo obj = new Demo();
        obj.show(a); // it will go to
        // byte argument
        obj.show("hello"); // String
        obj.show(250); // Int
        obj.show('A'); // Since char is
        // not available, so the datatype
        // higher than char in terms of
        // range is int.
        obj.show("A"); // String
        obj.show(7.5); // since float datatype
// is not available and so it's higher
// datatype, so at this step their
// will be an error.
}
}

有什么好处？
我们不必为做同样事情的函数创建和记住不同的名称。例如，在我们的代码中，如果Java不支持重载，我们将不得不创建方法名称，如 sum1、sum2、……或 sum2Int、sum3Int……等。

我们可以在返回类型上重载方法吗？
我们不能通过返回类型重载。这种行为在 C++ 中是相同的。有关详细信息，请参阅此

public class Main {
    public int foo() { return 10; }
  
    // compiler error: foo() is already defined
    public char foo() { return 'a'; }
  
    public static void main(String args[])
    {
    }
}

但是，在显式指定被调用函数的数据类型的情况下，可以在返回类型上重载方法。看看下面的例子：

// Java program to demonstrate the working of method
// overloading in static methods
public class Main {
  
    public static int foo(int a) { return 10; }
    public static char foo(int a, int b) { return 'a'; }
  
    public static void main(String args[])
    {
        System.out.println(foo(1));
        System.out.println(foo(1, 2));
    }
}

输出：

10
a

// Java program to demonstrate working of method
// overloading in  methods
class A {
    public int foo(int a) { return 10; }
  
    public char foo(int a, int b) { return 'a'; }
}
  
public class Main {
  
    public static void main(String args[])
    {
        A a = new A();
        System.out.println(a.foo(1));
        System.out.println(a.foo(1, 2));
    }
}

输出：

10
a

我们可以重载静态方法吗？
答案是'是'。我们可以有两个或多个同名但输入参数不同的静态方法。例如，考虑以下Java程序。有关详细信息，请参阅此。

我们可以重载仅通过静态关键字不同的方法吗？
如果它们仅通过静态关键字不同（参数数量和参数类型相同），我们不能在Java中重载两个方法。例如，请参见以下Java程序。有关详细信息，请参阅此。

我们可以在Java中重载 main() 吗？
像其他静态方法一样，我们可以在Java中重载 main()。有关详细信息，请参阅Java中的重载 main()。

// A Java program with overloaded main()
import java.io.*;
  
public class Test {
  
    // Normal main()
    public static void main(String[] args)
    {
        System.out.println("Hi Geek (from main)");
        Test.main("Geek");
    }
  
    // Overloaded main methods
    public static void main(String arg1)
    {
        System.out.println("Hi, " + arg1);
        Test.main("Dear Geek", "My Geek");
    }
    public static void main(String arg1, String arg2)
    {
        System.out.println("Hi, " + arg1 + ", " + arg2);
    }
}

输出：

Hi Geek (from main)
Hi, Geek
Hi, Dear Geek, My Geek

Java是否支持运算符重载？
与 C++ 不同， Java不允许用户定义的重载运算符。 Java在内部重载了运算符，例如，+ 被重载用于连接。

重载和覆盖有什么区别？

重载是关于相同的函数具有不同的签名。覆盖是关于相同的函数，相同的签名但通过继承连接的不同类。
重载是编译器时多态性的一个例子，而覆盖是运行时多态性的一个例子。

相关文章：

Java中方法重载的不同方式
Java中的方法重载和空错误
我们可以在Java中重载或覆盖静态方法吗？