方法重载
方法重载，解决了两个问题，第一：起名的问题，第二：记名的问题。
实现方法：在同一个类中声明多个名字相同的成员方法，但它们的形参(形式参数)列表不一样。
简单案例1：
1.打印 等边三角形 ，矩形 ，立方体 简单案例
import java.util.Scanner;
public class MethodOverloading
{
public static void main(String[] args){
//1.
MyPrint m = new MyPrint();
m.print(10);
m.print(10,20);
m.print(10,20,30);
}
}
// 1.打印 等边三角形 ，矩形 ，立方体 简单案例
class MyPrint
{
public void print(int len){
System.out.println("等边三角形 的边长为：" + len);
}
public void print(int len,int wide){
System.out.println("矩形 的长为：" + len + " 宽为：" + wide);
}
public void print(int len,int wide,int high){
System.out.println("立方体 的长为：" + len + " 宽为：" + wide + " 高为：" + high);
}
}
说明：
通过这个案例我们可以看到，同样是print()方法，但当形参列表不同时，它可以实现不同的功能。
简单案例2：
/*
2.在MethodUtils类，定义三个重载方法max()，
第一个方法，返回两个int值中的最大值，
第二个方法，返回两个double值中的最大值，
第三个方法，返回三个double值中的最大值，并分别调用三个方法。
*/
import java.util.Scanner;
public class MethodOverloading
{
public static void main(String[] args){
//2.
MethodUtils mu = new MethodUtils();
System.out.println(mu.max(10,20)); //20
System.out.println(mu.max(10.0,20.0)); //20.0
System.out.println(mu.max(10.0,20.0,30.0)); //30.0
}
}
class MethodUtils
{
public int max(int a,int b){
int res = a > b ? a:b;
return res;
}
public double max(double a,double b){
return a > b ? a:b;
}
public double max(double a,double b,double c){
return max(max(a,b),c);
}
}
说明：
通过案例2，我们可以看到，当形参个数相同时，只要形参类型相同，同样可以实现方法重载。
方法重载细节说明：
1) 方法名 ：必须相同
2) 参数列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）
3) 返回类型：无要求
方法重载对比
与void show(int a,char b,double c){}构成重载的是：[]
void show(int x,char y,double z){} // 不是
int show(int a,double c,char b){} // 是
void show(int a,double c,char b){} // 是
boolean show(int c,char b){} //是
void show(double c){} //是
double show(int x,char y,double z){} //不是
void shows(){} //不是
可变参数
应用场景：
面对未知的参数个数情况下，若使用方法重载，则有多少种参数变化就需要写多少种方法重载。因此使用可变参数可以在一个方法中完成未知参数个数的操作。
java提供了一种机制，可以允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。即可变参数。
基本语法
访问修饰符 返回类型 方法名(数据类型... 形参名){ }
简单案例
import java.util.Scanner;
public class VarArgs
{
public static void main(String[] args){
//一般使用方式
Var v = new Var();
int res = v.sum(1,2,3,4);
System.out.println("sum :" + res);
//数组使用方式
int[] a = {1,2,3,4};
int res1 = v.sum(a); //这种方式是被允许的
System.out.println("sum :" + res1);
}
//细节1： 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
public void m1(String name, String... args) {
//为什么可变参数在最后？
//理解：若可变参数不在最后语法上不好说明。
// 例：如果只有一个参数的情况下只能赋值给 name
// 而如果 args 在前面，就不能判断这个参数赋值给 args 还是 name
}
//细节2： 一个形参列表中只能出现一个可变参数
// public void m2(int... args1 , String... args2) {
// 这样声明会报错。
// }
}
class Var
{
//可以求多个参数的和
public int sum(int... a){
int sum = 0;
for(int i = 0 ;i<a.length;i++){
sum += a[i];
}
return sum;
}
}
说明：
-
int... 后面的三个小点，是规定，必须是"..."
-
这时 a 称为 可变形参，可变形参可以是 0个 和 任意个。
-
a 可变形参的本质就是数组
-
实参可以传递数组，但是需要通过 数组名
-
不能再在 Var 类中定义 sum(int[] a), 会认为重复定义
-
可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
-
一个形参列表中只能出现一个可变参数