Java——重载

一、重载（Overload）

1、重载是什么

方法重载（Method Overloading）是Java中实现多态的一种方式。它允许在同一个类中定义多个同名的方法，只要这些方法的参数列表不同。这些不同的参数列表可以通过不同的参数类型、参数数量或参数顺序来实现。

经常使用的 println 方法可已打印不同的数据类型就是重载实现的。

这里的不同的参数列表就实现了方法重载。

2、重载条件

重载的条件就是方法的方法名一样，参数列表不同。参数列表不同有多个情况：

1）参数类型不同：

不同的参数类型可以实现方法重载。

void print(int a) {
    System.out.println("int: " + a);
}
void print(double a) {
    System.out.println("double: " + a);
}

2）参数数量不同：

不同的参数数量可以实现方法重载。

void print(int a) {
    System.out.println("int: " + a);
}
void print(int a, int b) {
    System.out.println("int: " + a + ", int: " + b);
}

3）参数顺序不同：

同样类型但顺序不同的参数也可以实现方法重载。

void print(int a, double b) {
    System.out.println("int: " + a + ", double: " + b);
}
void print(double a, int b) {
    System.out.println("double: " + a + ", int: " + b);
}

3、方法重载的优点

• 提高代码可读性：使用相同的方法名称，有助于统一语义，增强代码的可读性。
• 灵活性和简洁性：可以根据不同的输入参数进行不同的处理，增强代码的灵活性和简洁性。

  4、重载注意事项

  返回类型不同不能作为重载依据：方法重载与返回类型无关，只看参数列表。

  参数名称不同不能作为重载依据：方法重载与参数名称无关，只看参数列表。

  方法修饰符无关：访问修饰符（如public、private等）不影响方法重载。

  抛出异常无关：方法抛出的异常类型和数量不会影响重载。

  二、重载示例

  1、计算两个数据的和

  下面的代码实现方法重载，一个方法是两个 int 参数，一个是两个 double 参数，两个方法方法名相同，实现重载，传入参数不同调用的方法不同。

  public class Test {
  	public static void main(String[] args) {
  		Calculator myCalculator = new Calculator();
  		int resOfInt = myCalculator.getSum(1, 2);//这里调用的是两个int参数的方法
  		double resOfDouble = myCalculator.getSum(1.1, 1.2);//这里调用的是两个double参数的方法
  		System.out.println("resOfInt = " + resOfInt);
  		System.out.println("resOfDouble = " + resOfDouble);
  	}
  }
  class Calculator{
  	
  	//参数为两个int
  	public int getSum(int a, int b) {
  		return a + b;
  	}
  	//参数为两个double
  	public double getSum(double a, double b) {
  		return a + b;
  	}
  }

  运行结果：

  

  可以发现传入的参数不同，调用的方法不同。

  2、计算两个数据的最大值

  public class Test {
  	public static void main(String[] args) {
  		Max max = new Max();
  		int resOfInt = max.getMax(1, 2);
  		double resOfDouble = max.getMax(1.1, 2.2);
  		System.out.println("resOfInt = " + resOfInt);
  		System.out.println("resOfDouble = " + resOfDouble);
  	}
  }
  class Max {
  	
  	//两个int型的参数
  	public int getMax(int a, int b) {
  		return a > b ? a : b;
  	}
  	//两个double型的参数
  	public double getMax(double a, double b) {
  		return a > b ? a : b;
  	}
  }

  运行结果：

  

  三、重载细节

  1、参数兼容

  public class Test {
  	public static void main(String[] args) {
  		Max max = new Max();
  		double res = max.getMax(2.2, 3.2, 4);//最后一个参数传的是int型，
  		//但依旧可以调用三个double类型的那个方法，
  		//是因为int可以自动转换为double类型
  		//这里最大值为4，因为自动转换为double类型，所以
  		//下面会打印4.0
  		System.out.println("res = " + res);
  	}
  }
  class Max {
  	
  	//两个int型的参数
  	public int getMax(int a, int b) {
  		return a > b ? a : b;
  	}
  	//两个double型的参数
  	public double getMax(double a, double b) {
  		return a > b ? a : b;
  	}
  	//三个double类型的参数，求三个数的最大值
  	public double getMax(double a, double b, double c) {
  		double max = a > b ? a : b;
  		return max > c ? max : c;
  	}
  }

  运行结果：

  

  可以发现方法重载时，方法调用的基本原理还是适用的，调用时，传入的参数只要与参数列表兼容（同一类型或者可以自动转换），就可以调用。

  2、最适配的方法

  public class Test {
  	public static void main(String[] args) {
  		Max max = new Max();
  		double res = max.getMax(2.2, 3.2, 4);//最后一个参数传的是int型，
  		//会调用两个double，一个int的方法，调用最适配的方法
  		System.out.println("res = " + res);
  	}
  }
  class Max {
  	
  	//两个int型的参数
  	public int getMax(int a, int b) {
  		return a > b ? a : b;
  	}
  	//两个double型的参数
  	public double getMax(double a, double b) {
  		return a > b ? a : b;
  	}
  	//三个double类型的参数，求三个数的最大值
  	public double getMax(double a, double b, double c) {
  		double max = a > b ? a : b;
  		return max > c ? max : c;
  	}
  	//两个double类型的参数，一个int类型的参数
  	public double getMax(double a, double b, int c) {
  		System.out.println("调用的是：public double getMax(double a, double b, int c)");
  		double max = a > b ? a : b;
  		return max > c ? max : c;
  	} 
  }

  运行结果：