7、方法重载
1、方法重载(Overload)的基本使用
对于功能类似的方法来说,因为参数列表不一样,却需要记住那么多不同的方法名称,太麻烦。
public class DemoelMethodOverload {
public static void main(String[] args) {
System.out.println(sumTwo(10, 20));//30
System.out.println(sumThree(10, 20, 30));//60
System.out.println(sumFour(10, 20, 30, 40));//100
}
public static int sumTwo(int a, int b) {
return a + b;
}
public static int sumThree(int a, int b, int c) {
return a + b + c;
}
public static int sumFour(int a, int b, int c, int d) {
return a + b + c + d;
}
}
方法的重载(Overload):多个方法的名称一样,但是参数列表不一样。
好处:只需要记住唯一一个方法名称,就可以实现类似的多个功能。
方法重载使用:
public class DemoelMethodOverload {
public static void main(String[] args) {
System.out.println(sum(10e, 20));//两个参数的方法
System.out.println(sum(10, 20, 30));//三个参数的方法
System.out.println(sum(10, 20, 30, 40));//四个参数的方法
//System.out.print1n(sum(a:10,b:20,c:30,d:40,50));
//找不到任何方法来匹配,所以错误!
}
//同一个sum,但是括号里有不同的参数列表
public static int sum(int a, int b) {
System.out.println("有2个参数的方法执行!");
return a + b;
}
public static int sum(int a, int b, int c) {
System.out.println("有3个参数的方法执行!");
return a + b + c;
}
public static int sum(int a, int b, int c, int d) {
System.out.println("有4个参数的方法执行!");
return a + b + c + d;
}
}
2、方法重载的注意事项
方法重载与下列因素相关:
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同
方法重载与下列因素无关:
1.与参数的名称无关
2.与方法的返回值类型无关
public static int sum(double a,double b){
return(int)(a+b);
}
public static int sum(int a,double b){
return(int)(a+b);
}
public static int sum(double a,int b){
return(int)(a+b);
}
//错误写法!与参数的名称无关
public static int sum(int x,int y){
return x+y;
}
//错误写法!与方法的返回值类型无判
public static double sum(int a,int b){
return a+b+0.0;
}
3、重载练习_四种不同参数类型的方法
public class MethodTest {
public static void main(String[] args) {
//调用方法
System.out.println(compare(10, 20));
System.out.println(compare((byte) 10, (byte) 20));
System.out.println(compare((short) 10, (short) 20));
System.out.println(compare(10L, 20L));
}
//int
public static boolean compare(int a, int b) {
System.out.println("int");
return a == b;
}
//byte
public static boolean compare(byte a, byte b) {
System.out.println("byte");
return a == b;
}
//short
public static boolean compare(short a, short b) {
System.out.println("short");
return a == b;
}
//long
public static boolean compare(long a, long b) {
System.out.println("long");
return a == b;
}
}
题目要求:
比较两个数据是否相等。
参数类型分别为两个byte类型,两个short类型,两个int类型,两个Long类型,并在main方法中进行测试。
/*
题目要求:
比较两个数据是否相等。
参数类型分别为两个byte类型,两个short类型,两个int类型,两个long类型,
并在main方法中进行测试。
*/
public class Demo02MethodOverloadSame {
public static void main(String[] args) {
byte a = 10;
byte b = 20;
System.out.println(isSame(a, b));
System.out.println(isSame((short) 20, (short) 20));
System.out.println(isSame(11, 12));
System.out.println(isSame(10L, 10L));
}
public static boolean isSame(byte a, byte b) {
System.out.println("两个byte参数的方法执行!");
boolean same;
if (a == b) {
same = true;
} else {
same = false;
}
return same;
}
public static boolean isSame(short a, short b) {
System.out.println("两个short参数的方法执行!");
boolean same = a == b ? true : false;
return same;
}
public static boolean isSame(int a, int b) {
System.out.println("两个int参数的方法执行!");
return a == b;
}
public static boolean isSame(long a, long b) {
System.out.println("两个long参数的方法执行!");
if (a == b) {
return true;
} else {
return false;
}
}
}
4、重载练习2_判断方法的正确重载
public static void open(){} //正确重载
public static void open(int a){} //正确重载
static void open(int a,int b){} //代码错误:和第8行冲突
public static void open(double a,int b){} //正确重载
public static void open(int a,double b){} //代码错误:和第6行冲突
public void open(int i,double d){} //代码错误:和第5行冲突
public static void OPEN(){} //代码正确不会报错,但是并不是有效重载
public static void open(int i,int j){} //代码错误:和第3行冲突
5、重载练习3_实现重载的println方法
shift+F6 用到的地方也会跟着改变
CTRL+鼠标点击 能出现println的各种方法重载的使用
// byte short int long float double char boolean
// String
// 在调用输出语句的时候,println方法其实就是进行了多种数据类型的重载形式。
public class Demo04OverloadPrint {
public static void main(String[] args) {
myPrint(100); // int
myPrint("Hello"); // String
}
public static void myPrint(byte num) {
System.out.println(num);
}
public static void myPrint(short num) {
System.out.println(num);
}
public static void myPrint(int num) {
System.out.println(num);
}
public static void myPrint(long num) {
System.out.println(num);
}
public static void myPrint(float num) {
System.out.println(num);
}
public static void myPrint(double num) {
System.out.println(num);
}
public static void myPrint(char zifu) {
System.out.println(zifu);
}
public static void myPrint(boolean is) {
System.out.println(is);
}
public static void myPrint(String str) {
System.out.println(str);
}
}
方法参数传递基本类型
重点关注两件事:
1、方法里面的形参在内存中也就是一个变量而已。
2、一个方法在调用传递参数的时候,如果传递的是基本数据类型,那么传递过去的就是该变量记录的具体数值
package com.itheima.param;
public class Test1 {
/*
方法参数传递为基本数据类型 :
传入方法中的, 是具体的数值.
*/
public static void main(String[] args) {
int number = 100;
System.out.println("调用change方法前:" + number);
change(number);
System.out.println("调用change方法后:" + number);
}
public static void change(int number) {
number = 200;
}
}
结论:
基本数据类型的参数,形式参数的改变,不影响实际参数
结论依据:
每个方法在栈内存中,都会有独立的栈空间,方法运行结束后就会弹栈消失
方法参数传递引用类型(数组)
重点:
如果一个方法参数传递的是引用数据类型,那么他会传递该引用数据类型中的所记录的内存地址
package com.itheima.param;
public class Test2 {
/*
方法参数传递为引用数据类型 :
传入方法中的, 是内存地址.
*/
public static void main(String[] args) {
int[] arr = {10, 20, 30};
System.out.println("调用change方法前:" + arr[1]);
change(arr);
System.out.println("调用change方法后:" + arr[1]);
}
public static void change(int[] arr) {
arr[1] = 200;
}
}
结论:
对于引用类型的参数,形式参数的改变,影响实际参数的值
结论依据:
引用数据类型的传参,传入的是地址值,内存中会造成两个引用指向同一个内存的效果,所以即使方法
弹栈,堆内存中的数据也已经是改变后的结果
数组遍历
package com.itheima.test;
public class Test1 {
/*
需求:设计一个方法用于数组遍历,要求遍历的结果是在一行上的。例如:[11, 22, 33, 44, 55]
思路:
1.定义一个数组,用静态初始化完成数组元素初始化
2.定义一个方法,对数组进行遍历
3.遍历打印的时候,数据不换行
4.调用遍历方法
*/
public static void main(String[] args) {
// 1.定义一个数组,用静态初始化完成数组元素初始化
int[] arr = {11, 22, 33, 44, 55};
// 4.调用遍历方法
printArray(arr);
System.out.println("另外一段代码逻辑 ");
}
/*
2.定义一个方法,对数组进行遍历
1, 参数 int[] arr
2, 返回值类型 void
*/
public static void printArray(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i == arr.length - 1) {
// 如果满足条件, 说明是最后一个元素, 最后一个元素, 特殊处理
System.out.println(arr[i] + "]");//print一定要加上ln 因为调用后要运行另一段代码逻辑需要换行
} else {
// 3.遍历打印的时候,数据不换行
System.out.print(arr[i] + ", ");
}
}
}
}
获取数组最大值
package com.itheima.test;
public class Test2 {
/*
需求:设计一个方法用于获取数组中元素的最大值
思路:
1.定义一个数组,用静态初始化完成数组元素初始化
2.定义一个方法,用来获取数组中的最大值
3.调用获取最大值方法,用变量接收返回结果
4.把结果输出在控制台
*/
public static void main(String[] args) {
// 1.定义一个数组,用静态初始化完成数组元素初始化
int[] arr = {11, 55, 22, 44, 33};
// 3.调用获取最大值方法,用变量接收返回结果
int max = getMax(arr);
// 4.把结果输出在控制台
System.out.println(max);
}
/*
2.定义一个方法,用来获取数组中的最大值
1, 参数 int[] arr
2, 返回值类型 int
*/
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
}
方法同时获取数组最大值和最小值
public class Test3 {
/*
需求:设计一个方法,该方法能够同时获取数组的最大值,和最小值
注意: return语句, 只能带回一个结果.
*/
public static void main(String[] args) {
int[] arr = {11, 55, 33, 22, 44};
int[] maxAndMin = getMaxAndMin(arr);
System.out.println(maxAndMin[0]);
System.out.println(maxAndMin[1]);
}
public static int[] getMaxAndMin(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (min > arr[i]) {
min = arr[i];
}
}
int[] maxAndMin = {min, max};
return maxAndMin;
}
}