详解：Java的重载方法与示例

方法重载是一项功能，如果一个类的参数列表不同，则它允许一个类拥有多个具有相同名称的方法。它类似于Java中的构造函数重载，它允许一个类具有多个具有不同参数列表的构造函数。

让我们回到重点，当我说参数列表时，它表示方法具有的参数：例如，具有两个参数的方法add（int a，int b）的参数列表与方法add的参数列表不同（int a，int b，int c）具有三个参数。

重载方法的三种方法

为了重载方法，方法的参数列表必须在以下两个方面有所不同：
1.参数数量。
例如：这是重载的有效情况

add(int, int)
add(int, int, int)

2.参数的数据类型。
例如：

add(int, int)
add(int, float)

3.参数的数据类型顺序。
例如：

add(int, float)
add(float, int)

方法重载的无效情况：
当我说参数列表时，我不是在说方法的返回类型，例如，如果两个方法具有相同的名称，相同的参数并且具有不同的返回类型，那么这不是有效的方法重载示例。这将引发编译错误。

int add(int, int)
float add(int, int)

方法重载是静态多态性一个示例。我们将在单独的教程中讨论多态性及其类型。

注意事项：
1. 静态多态也称为编译时绑定或早期绑定。
2. 静态绑定发生在编译时。方法重载是静态绑定的一个示例，其中方法调用对其定义的绑定发生在编译时。

方法重载示例

如本指南开头所讨论的，方法重载是通过声明具有不同参数的相同方法来完成的。参数必须在以下两个方面有所不同：参数（或参数）的数量，顺序或类型。让我们看一下每种情况的示例。

参数列表也称为参数列表

示例1：重载–参数列表中的参数数量不同

此示例说明如何通过具有不同数量的参数来完成方法重载

class DisplayOverloading
{
    public void disp(char c)
    {
         System.out.println(c);
    }
    public void disp(char c, int num)  
    {
         System.out.println(c + " "+num);
    }
}
class Sample
{
   public static void main(String args[])
   {
       DisplayOverloading obj = new DisplayOverloading();
       obj.disp('a');
       obj.disp('a',10);
   }
}

输出：

a
a 10

在上面的示例中-方法disp()根据参数数量而重载-我们有两种方法的名称，disp但它们具有的参数不同。两者都有不同数量的参数。

示例2：重载–参数数据类型的差异

在此示例中，方法disp（）基于参数的数据类型进行了重载–我们有两种名称为disp（）的方法，一种具有char类型的参数，另一种具有int类型的参数。

class DisplayOverloading2
{
    public void disp(char c)
    {
        System.out.println(c);
    }
    public void disp(int c)
    {
       System.out.println(c );
    }
}

class Sample2
{
    public static void main(String args[])
    {
        DisplayOverloading2 obj = new DisplayOverloading2();
        obj.disp('a');
        obj.disp(5);
    }
}

输出：

a
5

例3：重载–参数的数据类型顺序

在此，disp()根据参数的数据类型顺序重载方法–两种方法在参数列表中都有不同的数据类型顺序。第一种方法的参数列表为（char，int），第二种方法的参数为（int，char）。由于顺序不同，因此该方法可以重载而不会出现任何问题。

class DisplayOverloading3
{
   public void disp(char c, int num)
   {
       System.out.println("I’m the first definition of method disp");
   }
   public void disp(int num, char c)
   {
       System.out.println("I’m the second definition of method disp" );
   }
}
class Sample3
{
   public static void main(String args[])
   {
       DisplayOverloading3 obj = new DisplayOverloading3();
       obj.disp('x', 51 );
       obj.disp(52, 'y');
   }
}

输出：

I’m the first definition of method disp
I’m the second definition of method disp

方法重载和类型提升

例如，当将较小大小的数据类型提升为大于此大小的数据类型称为类型提升时，例如：字节数据类型可以提升为short，short数据类型可以提升为int，long，double等。

它与方法重载有什么关系？
好吧，了解类型提升非常重要，否则您会认为程序会引发编译错误，但实际上由于类型提升，程序可以正常运行。
让我们举个例子看看我在这里说什么：

class Demo{
   void disp(int a, double b){
	System.out.println("Method A");
   }
   void disp(int a, double b, double c){
	System.out.println("Method B");
   }
   public static void main(String args[]){
	Demo obj = new Demo();
	/* I am passing float value as a second argument but
	 * it got promoted to the type double, because there
	 * wasn't any method having arg list as (int, float)
	 */
	obj.disp(100, 20.67f);
   }
}

输出：

Method A

如您所见，我在调用disp（）方法时传递了float值，但是由于没有任何参数列表为（int，float）的方法，它被提升为double类型。

但是这种类型的促销并不总是会发生，让我们看另一个例子：

class Demo{
   void disp(int a, double b){
	System.out.println("Method A");
   }
   void disp(int a, double b, double c){
	System.out.println("Method B");
   }
   void disp(int a, float b){
	System.out.println("Method C");
   }
   public static void main(String args[]){
	Demo obj = new Demo();
	/* This time promotion won't happen as there is
	 * a method with arg list as (int, float)
	 */
	obj.disp(100, 20.67f);
   }
}

输出：

Method C

如您所见，由于存在一个具有匹配参数类型的方法，因此没有发生这种类型的升级。
类型提升表：
左侧的数据类型可以提升为右侧的任何数据类型。

byte → short → int → long
short → int → long
int → long → float → double
float → double
long → float → double

让我们看看方法重载的几种有效/无效情况

情况1：

int mymethod(int a, int b, float c)
int mymethod(int var1, int var2, float var3)

结果：编译时错误。参数列表完全相同。两种方法具有相同的编号，数据类型和相同的数据类型序列。

情况2：

int mymethod(int a, int b)
int mymethod(float var1, float var2)

结果：非常好。有效的重载情况。这里参数的数据类型是不同的。

情况3：

int mymethod(int a, int b)
int mymethod(int num)

结果：非常好。有效的重载情况。这里的参数数量是不同的。

情况4：

float mymethod(int a, float b)
float mymethod(float var1, int var2)

结果：非常好。有效的重载情况。参数的数据类型顺序不同，第一种方法具有（int，float），第二种方法具有（float，int）。

情况5：

int mymethod(int a, int b)
float mymethod(int var1, int var2)

结果：编译时错误。参数列表完全相同。即使方法的返回类型不同，也不是有效的情况。因为重载方法时方法的返回类型无关紧要。

在程序末尾检查之前，请先猜测答案：
问题1 –返回类型，方法名称和参数列表相同。

class Demo
{
   public int myMethod(int num1, int num2)
   { 
       System.out.println("First myMethod of class Demo");
       return num1+num2;
   }
   public int myMethod(int var1, int var2)
   {
       System.out.println("Second myMethod of class Demo");
       return var1-var2;
   }
}
class Sample4
{
   public static void main(String args[])
   {
       Demo obj1= new Demo();
       obj1.myMethod(10,10);
       obj1.myMethod(20,12);
   }
}

答案：
它将引发编译错误：同一类中不能定义多个具有相同名称和参数列表的方法。

问题2 –返回类型不同。方法名称和参数列表相同。

class Demo2
{
   public double myMethod(int num1, int num2)
   {
      System.out.println("First myMethod of class Demo");
      return num1+num2;
   }
   public int myMethod(int var1, int var2)
   {
      System.out.println("Second myMethod of class Demo");
      return var1-var2;
   }
}
class Sample5
{
   public static void main(String args[])
   {
      Demo2 obj2= new Demo2();
      obj2.myMethod(10,10);
      obj2.myMethod(20,12);
   }
}

答案：
它将引发编译错误：一个类中不能给出多个具有相同名称和参数列表的方法，即使它们的返回类型不同。在重载的情况下，方法返回类型无关紧要。