重载允许不同的方法具有相同的名称, 但签名不同, 签名可能因输入参数的数量或输入参数的类型或两者而不同。重载与编译时(或静态)多态性有关。
// 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问题出现：
问：如果确切的原型与参数不匹配怎么办？
Ans。
优先考虑, 编译器采取以下步骤：
- 类型转换, 但转换为同一系列中的更高类型(就范围而言)。
- 将类型转换为下一个更高的族(假设如果没有长数据类型可用于int数据类型, 则它将搜索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, …等。
我们可以在返回类型上重载方法吗？
We
不能
按返回类型重载。此行为在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程序。参考
这个
有关详细信息。
我们可以重载仅静态关键字不同的方法吗？
We
不能
如果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 GeekJava是否支持运算符重载？
与C ++不同, Java不允许用户定义重载运算符。 Java在内部重载运算符, 例如, +被重载以进行连接。
重载和覆盖之间有什么区别?
重载大约是相同的功能, 具有不同的签名。覆盖是关于相同的功能, 相同的签名, 但通过继承连接的不同类。
重载是编译器时间多态性的一个示例, 重载是运行时多态性的一个示例。
相关文章：
如果发现任何不正确的地方, 或者想分享有关上述主题的更多信息, 请写评论。
