java 方法重载 没有参数_Java基础之：方法重载与可变参数

Java基础之：方法重载与可变参数

方法重载

方法重载，解决了两个问题，第一：起名的问题，第二：记名的问题。

实现方法：在同一个类中声明多个名字相同的成员方法，但它们的形参(形式参数)列表不一样。

简单案例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

sum += a[i];

}

return sum;

}

}

说明：

int... 后面的三个小点，是规定，必须是"..."这时 a 称为 可变形参，可变形参可以是 0个 和 任意个。a 可变形参的本质就是数组实参可以传递数组，但是需要通过 数组名不能再在 Var 类中定义 sum(int[] a), 会认为重复定义

可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

一个形参列表中只能出现一个可变参数