# 【方法重载、Debug调试】
##### 今日复习指南
~~~
1.方法重载用(0.5个小时内完成,多写几遍)
Demo02OverLoad.java 定义四个重载的求和方法
Demo04OverLoadTest.java 定义四个重载的判断是否相同的方法
2.方法练习(1.0个小时内完成,多写几遍)
Demo02EachArrayMethod.java 定义方法打印int数组的内容
Demo03EachArrayMax.java 定义方法获取int数组最大值
3.方法参数区别和debug调试(0.5个小时内完成,演示效果)
Demo01DeBugSum.java
Demo02DeBug.java
~~~
##### 今日内容
~~~
方法的重载【重点】
方法的参数传递【难点】
方法练习【重点】
Debug调试【理解】
~~~
### 第一章 方法重载【理解】
##### 1.1 方法重载的引入
~~~
需求:
1.定义一个获取两个int数字之和的方法
2.定义一个获取三个int数字之和的方法
3.定义一个获取两个double数字之和的方法
4.定义一个获取三个double数字之和的方法
定义一个获取两个int数字之和的方法
三要素:
1.方法名称:
2.参数列表:
3.返回值类型:
发现问题:
以下四个方法,都是完成求和功能,只是参数列表不同,
然而我们却给每个方法起了一个相当之复杂的名字,
导致程序员使用和学习方法的成本增加(太复杂,记不住)
解决方案:
使用方法重载
~~~
~~~
public class Demo01Method {
public static void main(String[] args) {
System.out.println(getTwoIntNumSum(10,20));
System.out.println(getThreeIntNumSum(10,20,30));
System.out.println(getTwoDoubleNumSum(10.0,20.0));
System.out.println(getThreeDoubleNumSum(10.0,20.0,30.0));
}
//1.定义一个获取两个int数字之和的方法
public static int getTwoIntNumSum(int a, int b) {
System.out.println("两个int数字之和的方法被调用了.....");
return a + b;
}
//2.定义一个获取三个int数字之和的方法
public static int getThreeIntNumSum(int a, int b, int c) {
System.out.println("三个int数字之和的方法被调用了.....");
return a + b + c;
}
//3.定义一个获取两个double数字之和的方法
public static double getTwoDoubleNumSum(double a, double b) {
System.out.println("两个double数字之和的方法被调用了.....");
return a + b;
}
//4.定义一个获取三个double数字之和的方法
public static double getThreeDoubleNumSum(double a, double b,double c) {
System.out.println("三个double数字之和的方法被调用了.....");
return a + b + c;
}
}
~~~
##### 1.2 方法重载的概念
~~~
方法重载
1.概念:
在同一个类中,多个功能相同,但是参数列表不同的方法,可以使用相同的名字,这种多个同名不同参的方法,
可以存在于同一个类中的现象,叫做方法重载
简单来讲:
比如某个类中已经有了一个名字叫method的方法,我们可以再写多个名称叫method的方法,但是要求,
每个名称为method的方法,之间的参数列表必须要有区别
2.作用/目的:
(1)减少程序员的学习和使用的成本(原来必须要记4个方法名,现在只需要记一个方法名)
(2)减少了方法名称的数量
3.调用
(1)根据名称
(2)参数数量
(3)参数类型(优先做完全类型匹配,否则做自动类型提升的匹配)
~~~
~~~
public class Demo02OverLoad {
public static void main(String[] args) {
System.out.println(getSum(10,20));
System.out.println(getSum(10,20,30));
System.out.println(getSum(10.0,20.0));
System.out.println(getSum(10.0,20.0,30.0));
}
//1.定义一个获取两个int数字之和的方法
public static int getSum(int a, int b) {
System.out.println("两个int数字之和的方法被调用了.....");
return a + b;
}
//2.定义一个获取三个int数字之和的方法
public static int getSum(int a, int b, int c) {
System.out.println("三个int数字之和的方法被调用了.....");
return a + b + c;
}
//3.定义一个获取两个double数字之和的方法
public static double getSum(double a, double b) {
System.out.println("两个double数字之和的方法被调用了.....");
return a + b;
}
//4.定义一个获取三个double数字之和的方法
public static double getSum(double a, double b,double c) {
System.out.println("三个double数字之和的方法被调用了.....");
return a + b + c;
}
}
~~~
##### 1.3 方法重载的注意事项
~~~
/*
参数列表不同有哪些情况可以构成方法重载?
1.参数的数量不同
2.参数的类型不同
3.多个类型,顺序不同
总结:
方法重载的本质区别: 一定是看方法参数的数量和类型上的区别
*/
public class Demo02OverLoadNotice {
public static void main(String[] args) {
}
//1.没有参数
public static void method() {
}
//2.有一个int参数
//方法1没有参数,方法2有1个int参数,参数的数量不同可以构成重载
public static void method(int a) {
}
//3.有2个int参数
//方法3和方法2,参数数量不同,方法3和方法1参数数量也不同,参数的数量不同可以构成重载
public static void method(int a,int b) {
}
//4.有1个double参数
//方法4和方法1,都是1个参数,但是类型不同,参数的类型不同可以构成重载
public static void method(double a) {
}
//5.有两个double参数
//方法5有2个double参数,方法3有2个int参数,参数的类型不同可以构成重载
public static void method(double a,double b) {
}
//6.有一个int参数和一个double参数
public static void method(int a,double b) {
}
//7.有一个double参数和一个int参数
//方法6的参数先int后double,方法7的参数是先double后int,多个类型,顺序不同
public static void method(double a, int b) {
}
}
~~~
~~~
/*
方法重载与哪些因素无关?
1.与参数的名称无关
2.与返回值类型无关
3.与修饰符无关
*/
public class Demo03OverLoadNotice {
public static void main(String[] args) {
}
//1.有2个int参数
public static int method(int a, int b) {
return 200;
}
//2.有2个int参数
//报错: 不是方法重载,因为方法1和方法2,只有参数的名称不同,然而方法重载与参数名称无关
/*public static int method(int c, int d) {
return 100;
}*/
//3.有2个int参数
//报错: 不是方法重载,因为方法1和方法3,只有返回值类型不同,然而方法重载与返回值类型无关
/*public static double method(int a, int b) {
return 200.0;
}*/
//4.有2个int参数
//报错: 不是方法重载,因为方法1和方法4,只有修饰符不同,然后方法重载与修饰符无关
/*public int method(int a, int b) {
return 200;
}*/
//5.有2个int参数
//报错: 不是方法重载,因为方法1和方法5,只有修饰符不同,然后方法重载与修饰符无关
/*private int method(int a, int b) {
return 200;
}*/
}
~~~
##### 1.4 方法重载的练习-比较两个数据是否相等
~~~
/*
需求:
使用方法重载的思想，设计比较两个数据是否相等的方法，兼容全整数类型(byte,short,int,long）
方法重载的思想: 同一个类中,多个功能相同,参数列表不同的方法,可以使用同一个名字
实现步骤:
1.使用方法重载的思想,定义比较两个byte数据是否相同的方法compare
2.使用方法重载的思想,定义比较两个short数据是否相同的方法compare
3.使用方法重载的思想,定义比较两个int数据是否相同的方法compare
4.使用方法重载的思想,定义比较两个long数据是否相同的方法compare
5.调用以上四个方法
使用方法重载的思想,定义比较两个byte数据是否相同的方法compare
三要素:
1.方法名称: compare
2.参数列表: byte a, byte b
3.返回值类型: boolean
*/
public class Demo04OverLoadTest {
public static void main(String[] args) {
//调用以下四个方法: 传递变量
byte a = 10, b = 20;
System.out.println(compare(a, b));
short s1 = 10, s2 = 10;
System.out.println(compare(s1, s2));
int c = 100, d = 200;
System.out.println(compare(c, d));
long e = 1000L,f = 1000L;
System.out.println(compare(e,f));
}
//1.使用方法重载的思想,定义比较两个byte数据是否相同的方法compare
public static boolean compare(byte a, byte b) {
System.out.println("两个byte....");
if (a == b) {
return true;
} else {
return false;
}
}
//2.使用方法重载的思想,定义比较两个short数据是否相同的方法compare
public static boolean compare(short a, short b) {
System.out.println("两个short....");
if (a == b) {
return true;
}
//执行到这里,说明a和b一定是不相同的
return false;
}
//3.使用方法重载的思想,定义比较两个int数据是否相同的方法compare
public static boolean compare(int a, int b) {
System.out.println("两个int....");
return (a == b) ? true : false;
}
//4.使用方法重载的思想,定义比较两个long数据是否相同的方法compare
public static boolean compare(long a, long b) {
System.out.println("两个long....");
return a == b;
}
}
~~~
### 第二章 方法的参数传递【理解】
##### 2.1 方法参数传递
~~~
参数传递:
可以理解当我们要调用一个方法时，我们会把指定的数值，传递给方法中的参数(定义方法时()中定义的变量)，
这样方法中的参数就拥有了这个指定的值，可以使用该值，在方法中运算了。这种传递方式，我们称为参数传递。
形式参数: 定义方法时,()中定义的参数(1个/多个变量),叫做形式参数 定义时是没有值的
实际参数: 调用方法时,()中指定的数据(常量/变量),叫做实际参数 使用时必须是有值的
注意:
1.基本类型变量a的值赋值给基本类型变量b,其实是把a的值复制一份,赋值给b,之后不管如何修改变量b的值,都不会影响变量a中的值
2.局部变量:
(1)概念: 在定义方法方法()中定义的变量或者在方法内部定义的变量,都叫做局部变量
(2)特点: 只在方法内部有效,出了所在的方法,就无法使用了
public class Demo01Var {
public static void main(String[] args) {
//定义int变量a,并赋值
int a = 10;
//定义int变量b,未赋值
int b;
b = a;//把变量a的值赋(复制)值给变量b
System.out.println("a="+a);//10
System.out.println("b="+b);//10
b = b*10;
System.out.println("a="+a);//10
System.out.println("b="+b);//100
//c是在method方法中定义的,出了method方法,就不能使用了
//System.out.println(c);
method(a,b);//a和b既叫做实际参数,有叫做局部变量
}
public static void method(int m,int n) {//m和n既叫做形式参数,有叫做局部变量
//a和b是在main方法中定义的,出了main方法,就不能使用了
//System.out.println(a);
//System.out.println(b);
int c = 2000;
System.out.println(c);
}
}
~~~
图解:
##### 2.2 基本类型作为方法参数传递
~~~
基本类型作为方法参数传递的特点
1.基本类型变量,保存的是具体的数据值
2.基本类型变量作为方法参数传递时,传递的也是具体的数据值
3.基本类型变量作为方法参数传递特点:
形式参数的改变,不会影响实际参数
形式参数: 定义方法时,()中定义的变量
实际参数: 调用方法时,()中给出的数据/变量
change方法内部修改形式参数a和b的值,不会影响main方法中实际参数a和b的值
基本类型作为方法的形式参数时,形式参数的改变,不会影响实际参数
注意:
1.每个方法的执行都有自己独立的内存空间(在栈中)
2.方法内部定义的变量,也有自己独立的内存空间
总结:
1.不同的方法内部可以定义相同名称的变量
2.每个方法有自己独立的空间,方法中的变量也有自己独立的空间,它们之间是互不影响,互不干扰的
~~~
~~~
public class Demo02BaseVar {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println("ms...a="+a);//10
System.out.println("ms...b="+b);//20
change(a,b);
System.out.println("me...a="+a);//10
System.out.println("me...b="+b);//20
}
public static void change(int a,int b) {
System.out.println("cs...a="+a);//10
System.out.println("cs...b="+b);//20
a = a * 10;
b = b * 10;
System.out.println("ce...a="+a);//100
System.out.println("ce...b="+b);//200
}
}
~~~
##### 图解:
##### 2.2 引用类型作为方法参数传递
~~~
引用类型作为方法参数传递的特点
1.引用类型变量,保存的是堆内存中的地址值
2.引用类型变量作为方法参数传递时,传递的也是具体的堆内存中的地址值
3.引用类型变量作为方法参数传递特点:
引用类型变量作为方法的形式参数时,通过形式参数找到对应的堆内存空间的内容进行修改,
再通过实际参数看到的就是修改之后的内容
引用类型作为方法的形式参数时,形式参数的改变,会影响实际参数
数组作为方法参数传递的特点
1.数组变量名称保存的是数组在堆内存空间的地址值
2.数组作为方法参数传递时,传递的是地址值
3.数组作为方法形式参数时,通过形式参数找到堆内存中的数组,修改其内容后,实际参数看到的是修改之后的
数组作为方法的形式参数时,形式参数的改变,会影响实际参数
~~~
~~~
public class Demo03RefVar {
public static void main(String[] args) {
int[] arr = {10,20};
System.out.println("ms...arr[0]="+arr[0]);//10
System.out.println("ms...arr[1]="+arr[1]);//20
change( arr );//实际参数
System.out.println("me...arr[0]="+arr[0]);//100
System.out.println("me...arr[1]="+arr[1]);//200
}
public static void change(int[] arr) {//arr: 形式参数
System.out.println("cs...arr[0]="+arr[0]);//10
System.out.println("cs...arr[1]="+arr[1]);//20
arr[0] = arr[0] * 10;
arr[1] = arr[1] * 10;
System.out.println("ce...arr[0]="+arr[0]);//100
System.out.println("ce...arr[1]="+arr[1]);//200
return ;
}
}
~~~
图解:
### 第三章 方法的练习【重点】
##### 3.1 数组遍历练习(不定义方法)
~~~
/*
需求(先不定义方法):
完成数组的遍历(打印数组元素)，要求遍历的结果是在一行上的。
例如：[11, 22, 33, 44, 55]
举例:
原数组: {11,22,33,44,55}
打印格式:[11, 22, 33, 44, 55]
实现步骤:
1.定义int数组array,并初始化
2.打印"[",不换行
3.使用for循环遍历数组
3.1 打印当前元素,不换行
3.2 如果3.1中打印的不是最后一个元素,打印", ",不换行
4.打印"]"
问题:
因为没有把打印数组内容的功能,定义成方法,所以有多少个数组,打印数组的代码就得重复多少遍
解决方案:
把按照指定格式打印数组内容的功能,定义成方法
*/
public class Demo01EachArray {
public static void main(String[] args) {
//1.定义int数组array,并初始化
int[] array = {11,22,33,44,55};
//2.打印"[",不换行
System.out.print("[");
//3.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//3.1 打印当前元素,不换行
System.out.print(array[i]);
//3.2 如果3.1中打印的不是最后一个元素,打印", ",不换行
if (i != array.length - 1) {
System.out.print(", ");
}
}
//4.打印"]"
System.out.println("]");
System.out.println("------------------------");
//int数组变量,指向了新的数组
array = new int[] {100,200,300,500,800};
//2.打印"[",不换行
System.out.print("[");
//3.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//3.1 打印当前元素,不换行
System.out.print(array[i]);
//3.2 如果3.1中打印的不是最后一个元素,打印", ",不换行
if (i != array.length - 1) {
System.out.print(", ");
}
}
//4.打印"]"
System.out.println("]");
}
}
~~~
##### 3.2 数组遍历练习(定义方法)
~~~
/*
需求(定义方法):
设计一个方法用于int数组遍历(打印数组元素)，
要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
举例:
原数组: {11,22,33,44,55}
打印格式:[11, 22, 33, 44, 55]
定义方法,用来遍历int数组
三要素:
1.方法名称: printArray
2.参数列表: int[] array 因为只有int类型数组变量才可以结束int类型的数组
3.返回值类型: void
实现步骤:
1.打印"[",不换行
2.使用for循环遍历数组
2.1 打印当前元素,不换行
2.2 如果3.1中打印的不是最后一个元素,打印", ",不换行
3.打印"]"
main方法的实现步骤:
1.定义printArray方法,用来遍历int数组
2.定义int数组array,并初始化
3.调用printArray方法,传递int数组array
*/
public class Demo02EachArrayMethod {
public static void main(String[] args) {
//2.定义int数组array,并初始化
int[] array = {11,22,33,44,55};//数组名array: 保存的是数组在内存空间的地址值
//3.调用printArray方法,传递int数组array
printArray(array);//传递的是数组在内存空间的地址值
//数组变量array,又指向了一个新的数组
array = new int[] {110,220,330,440,550};
printArray(array);
}
//定义方法,用来遍历int数组
public static void printArray(int[] array) {
//1.打印"[",不换行
System.out.print("[");
//2.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//2.1 打印当前元素,不换行
System.out.print(array[i]);
//2.2 如果3.1中打印的不是最后一个元素,打印", ",不换行
if (i != array.length - 1) {
System.out.print(", ");
}
}
//3.打印"]"
System.out.println("]");
}
}
~~~
##### 3.2 方法练习求数组最大值
~~~
package com.itheima03;
/*
需求:
设计一个方法用于获取int数组中元素的最大值
举例:
原数组: {11,22,33,44,55}
最大值: 55
三要素:
1.方法名称: getArrayMax
2.参数列表: int[] array
3.返回值类型: int
获取int数组中元素的最大值方法的实现步骤:
1.假设数组array中索引0对应的元素是最大的,保存到int变量max中
2.使用for循环遍历数组,依次获取后面的(从索引1开始)每个元素
2.1 如果当前元素值 大于 max 说明max中的值已经不是最大的了,把当前元素值 赋值 给 max
3.for循环结束,返回max
main方法的实现步骤
1.定义获取int数组最大值的方法getArrayMax
2.定义int数组array,并初始化
3.调用getArrayMax方法,传递int数组array,获取最大值保存到int变量max中
4.打印max的值
*/
public class Demo03EachArrayMax {
public static void main(String[] args) {
//1.定义获取int数组最大值的方法getArrayMax
//2.定义int数组array,并初始化
int[] array = {11,22,33,44,55};
//3.调用getArrayMax方法,传递int数组array,获取最大值保存到int变量max中
int max = getArrayMax(array);
//4.打印max的值
System.out.print("原数组:");
printArray(array);
System.out.println("最大值: "+max);
}
//设计一个方法用于获取int数组中元素的最大值
public static int getArrayMax(int[] array) {
//1.假设数组array中索引0对应的元素是最大的,保存到int变量max中
int max = array[0];
//2.使用for循环遍历数组,依次获取后面的(从索引1开始)每个元素
for (int i = 1; i < array.length; i++) {
//2.1 如果当前元素值 大于 max 说明max中的值已经不是最大的了,把当前元素值 赋值 给 max
if (array[i] > max) {
max = array[i];
}
}
//3.for循环结束,返回max
return max;
}
//定义方法,用来遍历int数组
public static void printArray(int[] array) {
//1.打印"[",不换行
System.out.print("[");
//2.使用for循环遍历数组
for (int i = 0; i < array.length; i++) {
//2.1 打印当前元素,不换行
System.out.print(array[i]);
//2.2 如果3.1中打印的不是最后一个元素,打印", ",不换行
if (i != array.length - 1) {
System.out.print(", ");
}
}
//3.打印"]"
System.out.println("]");
}
}
~~~
##### 3.3 引用类型变量作为方法参数方法调用图解
### 第四章 Debug调试【重点】
##### 4.1 Debug查看求和
~~~
使用步骤:
1.在代码的第一行左侧空白(行号后面)处单击鼠标左键,添加断点
2.右键选择"debug...",进入断点调试界面
public class Demo01DeBugSum {
public static void main(String[] args) {
System.out.println("main...start....");
int a = 10;
int b = 20;
int sum = a + b;
System.out.println("sum="+sum);
System.out.println("main...end....");
}
}
~~~
##### 4.2 Debug查看求和方法
~~~
public class Demo02DeBug {
public static void main(String[] args) {
System.out.println("main...start...");
method();
System.out.println("main...end...");
}
public static void method() {
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
return ;
}
}
~~~
##### 总结
~~~
能够知道方法重载的特点
1.同一个类中,多个名称相同,参数列表不同的方法,可以使用相同的名称
2.参数列表不同有哪些情况?
(1)个数不同
(2)类型不同
(3)多个类型顺序不同
3.与哪些因素无关
(1)与参数名称无关
(2)与返回值类型无关
(3)与修饰符无关
能够使用方法重载完成比较两个整数是否相同并调用方法
sout(compare(10,20));//调用参数是2个int的compare方法
sout(compare((byte)10,(byte)20));//调用参数是2个byte的compare方法
//获取2个byte数据是否相同
public static boolean compare(byte a,byte b) {
return a == b;
}
//获取2个int数据是否相同
public static boolean compare(int a,int b) {
return a == b;
}
能够使用方法完成数组遍历并调用方法
public static void printArray(int[] array) {
System.out.print("[");
for(int i = 0;i<array.length;i++) {
System.out.print(array[i]);
if(i != array.length-1) {
System.out.print(", ");
}
}
System.out.println("]");
}
能够使用方法完成获取int数组最大值并调用方法
public static int getArrayMax(int[] array) {
int max = array[0];
for(int i = 1;i<array.length;i++) {
if(array[i] > max) {
max = array[i];
}
}
return max;
}
能够使用断点调试查看循环求和流程
能够知道方法的参数是基本类型和引用类型的区别
方法的参数是基本类型特点: 形参的改变不会影响实参
方法的参数是引用类型特点: 形参的改变会影响实参
~~~
