Java方法重载介绍和用法实例

2021年3月24日14:48:42 发表评论 703 次浏览

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

// 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。

优先考虑, 编译器采取以下步骤:

  1. 类型转换, 但转换为同一系列中的更高类型(就范围而言)。
  2. 将类型转换为下一个更高的族(假设如果没有长数据类型可用于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 Geek

Java是否支持运算符重载?

与C ++不同, Java不允许用户定义重载运算符。 Java在内部重载运算符, 例如, +被重载以进行连接。

重载和覆盖之间有什么区别?

重载大约是相同的功能, 具有不同的签名。覆盖是关于相同的功能, 相同的签名, 但通过继承连接的不同类。

OverrideingVsOverloading

重载是编译器时间多态性的一个示例, 重载是运行时多态性的一个示例。

相关文章:

  • Java中方法重载的不同方法
  • Java中的方法重载和Null错误
  • 我们可以在Java中重载或重写静态方法吗?

如果发现任何不正确的地方, 或者想分享有关上述主题的更多信息, 请写评论。

木子山

发表评论

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: