Java 方法重载

Java编程语言中的方法重载是在一个类中定义两个或多个同名方法。只要它们拥有唯一的一组参数或形参，该编程语言就允许我们为多个定义指定相同的名称，并称之为方法重载。这种唯一性有助于编译器区分一个方法与另一个方法，从而可以根据参数调用相应的方法。

我们已经见过许多Java方法重载技术，但您可能没有注意到。例如，我们在上一篇文章中解释过的Arrays.Sort函数，或者System.out.println函数，都接受多种数据类型作为参数。

可以通过更改参数数量来实现方法重载。请参考示例1。否则，至少有一个参数的数据类型应有所更改。请参考示例2、3和4。

Javac不认为以下定义是Java方法重载。也许会抛出错误

  • 更改参数名称。请参考示例6。
  • 更改函数的返回类型。请参考示例7。

Java 方法重载示例

这个程序将展示如何通过更改参数数量来执行方法重载。首先，我们创建了一个类，并在类中定义了两个同名函数，但我们更改了参数的数量。

public class Example {
	public void sum(int a, int b) { // F1
		System.out.format("The Sum of Two Numbers is = %d \n", (a + b));
	}
	
	public void sum(int a, int b, int c) { //F2
		System.out.format("The Sum of Three Numbers is = %d", (a + b + c));
	}
}

在这个Java方法重载的main方法中，我们创建了上述类的对象/实例，并在其中调用了函数。

public class FindTotal {
	public static void main(String[] args) {
		Example obj = new Example();
		obj.sum(10, 20); // Calling F1
		obj.sum(10, 20, 40); // Calling F2
	}
}
Method Overloading in Java 1

在这个方法重载程序中，以下语句允许我们创建Example类的实例。

Example obj = new Example();

由于我们向sum传递了两个参数，编译器将调用第一个：public void sum(int a, int b)

obj.sum(10, 20);

下一行，我们向sum传递了三个参数。因此，编译器将调用第二个：public void sum(int a, int b, int c)

obj.sum(10, 20, 40);

通过更改数据类型进行Java方法重载

在这个程序中，我们将展示如何通过更改参数的数据类型来执行方法重载。首先，我们创建了一个类，并在类中定义了三个同名函数，但我们更改了两个参数的数据类型。

public class Simple {
	public void add(int a, int b) { //function F1
		System.out.format("The Sum of Two Integer Values = %d \n", (a + b));
	}	
	public void add(float a, float b) { //function F2
		System.out.format("The Sum of Two Float Values = %.4f \n", (a + b));
	}
	public void add(String str1, String str2) { //function F3
		System.out.println("The Sum of Three Numbers is = " + (str1 + str2));
	}
}

在方法重载的main程序中，我们创建了上述类的对象/实例。这允许我们调用Sample中的函数。

public class Sample {
	public static void main(String[] args) {
		Simple obj = new Simple();
		obj.add(10, 20); // Calling F1
		obj.add(20.34f, 40.92f); // Calling F2
		obj.add("Tutorial ", "Gateway"); // Calling F3
	}
}
The Total of Two Integer Values = 30 
The Total of Two Float Values = 61.2600 
The Total of Three Numbers is = Tutorial Gateway

Java方法重载中的第一个语句允许我们创建Simple类的实例。由于我们向add传递了两个整数值，编译器将调用第一个：public void add(int a, int b)

obj.add(10, 20);

下一行，我们向add传递了两个浮点数值。因此，编译器将调用第二个：public void add(float a, float b)

obj.add(20.34f, 40.92f);

示例中的下一行，我们向add传递了两个字符串。在这里，编译器将调用第三个：public void add(String str1, String str2) 来执行字符串连接。

obj.add("Tutorial ", "Gateway");

更改方法重载中的数据类型

在我们之前的Java方法重载示例中，我们更改了所有可用参数的数据类型。在这个程序中，我们将展示当我们更改单个参数的数据类型以及更改参数顺序时会发生什么。

为了做到这一点，我们首先创建了一个Java类，并在类中定义了三个同名函数。但是，我们更改了单个参数的数据类型和参数的顺序。

public class Simple {
	public void add(int a, int b) { //function F1
		System.out.format("The Sum of Two Integer Values = %d \n", (a + b));
	}	
	public void add(int a, float b) { //function F3
		System.out.format("The Sum of Int & Float Values = %.4f \n", (a + b));
	}
	public void add(float a, int b) { //function F3
		System.out.format("The Sum of Float & Int Values = %.4f \n", (a + b));
	}
}

在方法重载的main示例中，我们创建了上述类的对象/实例。这允许我们调用Sample中的函数。

public class Sample {
	public static void main(String[] args) {
		Simple obj = new Simple();
		obj.add(10, 20); // Calling F1
		obj.add(30, 40.92f); // Calling F2
		obj.add(60.98f, 20); // Calling F3
	}
}
The Sum of Two Integer Values = 30
The Sum of Int & Float Values = 70.9200
The Sum of Float & Int Values = 80.9800

在此示例中，第一个语句允许我们创建Simple类的实例。由于我们向add传递了两个整数值，编译器将调用add(int a, int b)

obj.add(10, 20); // F1

下一行，我们向add传递了一个整数值和一个浮点数值。因此，编译器将调用add(int a, float b)

obj.add(30, 40.92f); // F2

下一行，我们向add传递了一个浮点数值和一个整数值。因此，编译器将调用第三个add( float a, int b)

obj.add(60.98f, 20); // F3

使用参数数量进行方法重载

这个程序将展示在方法重载过程中它如何隐式地进行类型转换。为此，我们首先创建了一个类，并在类中定义了两个同名函数。但是，我们更改了第二个函数参数的数据类型。

请记住，我们在第二个参数中使用了三个参数以便于理解，如果您想要两个参数，请坚持使用两个。

public class Simple {
	public void add(int a, int b) { //F1
		System.out.format("The Sum of Two Integer Values = %d \n", (a + b));
	}	
	public void add(int a, long b, long c) { //F2
		System.out.format("The Sum of Int & Long Values = %d \n", (a + b + c));
	}
}

在这个Java方法重载的main部分，我们创建了上述类的对象/实例。这允许我们调用Sample中的函数。

public class Sample {
	public static void main(String[] args) {
		Simple obj = new Simple();
		obj.add(15, 45); // Calling F1
		obj.add(30, 90, 220); // Calling F2
	}
}
The Sum of Two Integer Values = 60
The Sum of Int & Long Values = 340

以下语句允许我们创建Simple类的实例。

Simple obj = new Simple();

由于我们向add传递了两个整数值，编译器将调用第一个：dd(int a, int b)

obj.add(15, 45);

下一行，我们向add传递了一个整数值和两个long值。因此，编译器将调用第二个：public void add(int a, long b, long c)。在这里，该函数将隐式地将整数值转换为long类型并执行加法运算。

obj.add(30, 90, 220);

Java方法重载编译问题：歧义

这个程序将展示当我们交换参数的数据类型时会发生什么。对于这个方法重载示例，我们首先创建了一个类。在该类中，我们定义了两个同名函数，但我们交换了参数的数据类型。

public class Simple {
	public void add(int a, long b) { //function F1
		System.out.format("The Output from First = %d \n", (a + b));
	}	
	public void add(long a, int b) { //function F2
		System.out.format("The Output from Second = %d \n", (a + b));
	}
}

在方法重载的main程序中，我们创建了上述类的对象/实例。这允许我们调用Sample中的函数。

public class Sample {
	public static void main(String[] args) {
		Simple obj = new Simple();
		obj.add(15, 45); 
	}
}
Method Overloading 5

在这个示例中，下面的语句允许我们创建Simple类的实例。

Simple obj = new Simple();

在这里，编译器将无法理解它应该调用哪个函数。因为第一个函数public void add(int a, long b)和第二个函数public void add(int a, long b)都是有效的。这就是为什么它会抛出一个错误，说明函数是歧义的。

obj.add(15, 45);

Java方法重载重复错误

这个方法重载程序将展示当我们更改参数名称时会发生什么。首先，我们创建了一个类，并在类中定义了两个同名且参数相同的函数。但是，我们将参数名称从a更改为x，从b更改为y。

public class Simple {
	public void add(int a, int b) { 
		System.out.format("The Output from First = %d \n", (a + b));
	}	
	public void add(int x, int y) { 
		System.out.format("The Output from Second = %d \n", (a + b));
	}
}

声明这不是方法重载，并且不应鼓励。

Method Overloading Error

这个程序将展示当我们更改返回类型时会发生什么。为此，首先我们创建了一个类，并在类中定义了两个同名且参数相同的函数，但我们将返回类型更改为double。

public class Simple {
	public int add(int a, int b) { //function F1
		int c = a + b;
		return c;
	}	
	public double add(int a, int b) { //function F2
		double c = a + b;
		return c;
	}
}

声明这不是Java方法重载，并且不应鼓励。

Duplicate Name Error Message