1，回顾
方法的完整格式：
public static 返回值类型 方法名(数据类型 变量名，数据类型 变量名。。。){
方法体;
return 数值；
}
public static ：目前我们暂时先认为是固定格式。
返回值类型：如果方法没有返回值，写void。
如果方法有返回值，返回什么数据，那么就需要写什么类型。
方法名：是我们自己起的名字，要遵守，见名知意，小驼峰命名。
一个单词，全部小写。 ---- main
多个单词，从第二个单词开始首字母大写。 ---- getSum
形参：全称形式参数。在定义的时候是不给值的。当方法被调用的时候，才有值。
如果小括号中有多个形参，那么中间需要用逗号隔开。
方法体，就是方法自身的逻辑。
return：
1，结束方法。
2，将后面的值返回给调用者。
方法的调用格式：
- 直接调用 getSum（）；对方法的返回值不做任何处理。适用于没有返回值的方法。
- 赋值调用 int sum = getSum(); 把方法的返回值赋值给一个变量。
- 输出调用 System.out.println(getSum()); 把方法的返回值直接打印在控制台上。
如果现在是一个有返回值的方法，建议使用赋值调用。
方法的注意点：
- 方法在定义的时候不能嵌套。
- 方法的返回值类型为void表示没有返回值，此时return可以省略。
如果此时还是写了return，那么后面就不能写返回的值。此时return表示结束方法。 - return的下面，不能再写其他的代码，因为永远执行不到。
2，方法的重载
什么是方法的重载：
在同一个类中，有相同名字的方法。 参数不一样，与返回值无关。
参数不一样：个数不一样。数据类型不一样。数据类型的顺序不一样。
方法重载要掌握的知识点：
给你一个案例，要能辨别，是否构成重载关系
判断技巧：
1，两个方法必须要在同一个类中。
2，两个方法的方法名必须一致。
3，两个方法的参数必须不一样。（个数不一样， 类型不一样，类型的顺序不一样）
4，方法的重载跟返回值没有任何关系。
前面的三个，只要有一个不满足，那么就无法构成方法的重载。
类型的顺序不一样：仅仅跟数据类型有关，跟变量的名字是没有任何关系的。
方法重载的好处：
针对于定义方法的人：在书写方法的时候，可以定义相同名字的方法了。
会把相同功能的方法，他的名字都定义成一样的。
针对于调用者来讲： 在调用的时候，就不需要记那么多方法了。
同种功能的方法，只要记住其中的一个。
案例1：
public class MethodDemo2 {
public static void main(String[] args) {
//写一个方法，判断两个数据是否相等（ byte short int long）
compare(10,20); //--- 思考一下，现在调用的是哪个方法？
//int
}
//判断两个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;
}
//判断两个int是否相等
public static boolean compare(int a, int b){
System.out.println("---------int--------------");
return a == b;
}
//判断两个long是否相等
public static boolean compare(long a, long b){
System.out.println("---------long--------------");
return a == b;
}
}案例2：
public class MethodDemo3 {
//下面的这两个方法，不够成重载关系。
//因为他们类型和类型的顺序都是一样的。跟变量名无关
public static boolean compare(int a, byte b){
return a == b;
}
public static boolean compare(int b, byte a){
return a == b;
}
}3，基本数据类型作为值传递
public class MethodDemo3 {
public static void main(String[] args) {
int number = 100;//在main方法中定义了一个变量number，并赋值为100.
System.out.println("调用前" + number);//打印number变量里面的值。--- 100
change(number);//调用方法，把number变量里面的值传递给了change方法。
System.out.println("调用后" + number);//100
}
public static void change(int a) {//当100传递过来的时候，被这里的形参a给接收了。
//修改一下number的值
a = 200;//把change方法里面的a记录的值修改为了200.
}
}
//问： main方法里面的number和change方法里面的number是同一个变量吗？
//不是同一个变量。两个完全不一样的变量，只不过刚好名字都叫number而已。
//学习变量 --- 变量的作用范围 --- 只在所属的大括号中有效结论：
（前提条件：当前方法没有返回值）
基本数据类型作为值传递，如果我们在方法中修改了变量的值。
那么不会影响调用处变量的值。
说明：
只要大家掌握这种没有返回值的即可。
带有返回值的，了解就行。
4，引用数据类型作为值传递
public class MethodDemo5 {
public static void main(String[] args) {
String [] arr = {"苹果" , "梨"};
System.out.println("调用前" + arr[0] + arr[1]);//苹果,梨
change(arr);
System.out.println("调用后" + arr[0] + arr[1]);//苹果核,梨
}
public static void change(String[] arr) {
arr[0] = "苹果核";
}
}结论：
引用数据类型作为值传递，如果在方法中修改了对应的值。
那么调用处再次访问的时候，就是修改之后的结果。
5，多个练习
案例1：定义一个方法遍历数组。
核心：在调用方法的时候，会把变量arr记录的地址值传递给方法。
所以在方法中，才能够遍历这个数组。
public class Test1 {
public static void main(String[] args) {
//定义一个方法用来遍历数组
//1.定义一个数组
int [] arr = {11,22,33,44,55,66};
//写一个方法遍历这个arr数组
printArr(arr);//把arr这个变量记录的地址值传递给了printArr方法。
//所以，下面的printArr方法，才能够进行遍历。
}
public static void printArr(int[] arr) {
System.out.print("[");
//遍历数组
for (int i = 0; i < arr.length; i++) {
//arr[i] 依次表示数组中的每一个值
if(i == arr.length - 1){//判断当前的i是否为最后一个索引
System.out.print(arr[i]);
}else{
System.out.print(arr[i] + ", ");
}
}
System.out.print("]");
}
}案例2：定义一个方法求数组的最大值
核心：在调用方法的时候，会把变量arr记录的地址值传递给方法。
所以在方法中，才就可以求这个数组的最大值。
public class Test2 {
public static void main(String[] args) {
//定义一个方法，求数组的最大值
//1.定义一个数组
int[] arr1 = {7, 9, 11, 22, 45, 16};
//调用方法求最大值
int max1 = getMax(arr1);//把变量arr1记录的地址值传递给下面的getMax方法
//所以此时，求的就是arr1记录的数组的最大值。
System.out.println(max1);//45
//2.再定义一个数组求最大值
int[] arr2 = {17, 19, 111, 222, 145, 116};
//调用方法求最大值
int max2 = getMax(arr2);//把变量arr2记录的地址值传递给下面的getMax方法
//所以此时，求的就是arr2记录的数组的最大值。
System.out.println(max2);//222
}
public static int getMax(int[] arr) {
int max = arr[0];
//就要在方法中求最大值了
for (int i = 0; i < arr.length; i++) {
//arr[i] 依次表示数组中的每一个元素
if(arr[i] > max){
max = arr[i];
}
}
return max;
}
}案例3：变量的交换
//数字交换
int a = 10;
int b = 20;
//定义一个临时变量。记录变量a的值10
int temp = a;
//把变量b的值交给变量a。
a = b;
//把临时变量里面记录的10，交给b
b = temp;
System.out.println(a);
System.out.println(b);案例4：交换数组中的元素
public class Test4 {
public static void main(String[] args) {
//1.定义数组
int[] arr = {11, 22, 33, 44, 55, 66};
//2,遍历数组
System.out.print("交换前：");
printArr(arr);//传递的是变量arr记录的地址值。
//2.调用方法
change(arr);//此时调用change方法，传递的也是变量arr记录的地址值。
//3.遍历数组
//2,遍历数组
System.out.print("交换后：");
printArr(arr);//传递的是变量arr记录的地址值。
}
//可以调换1索引和5索引上面的元素
public static void change(int [] arr){
int temp = arr[1];
arr[1] = arr[5];
arr[5] = temp;
}
//遍历数组
public static void printArr(int[] arr) {
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
//arr[i] 依次表示数组中的每一个值
if(i == arr.length - 1){//判断当前的i是否为最后一个索引
System.out.print(arr[i]);
}else{
System.out.print(arr[i] + ", ");
}
}
System.out.println("]");
}
}6，Debug
作用：
可以查看程序的执行流程。
简单理解：
可以看程序是如何一步一步的执行的。
使用方式：
1，打断点。
- 想查看所有代码是如何一步一步执行的。
可以在方法的第一行有效语句前面打上断点。
如果想要查看的代码，有多个方法，需要在每一个方法的第一行有效语句前面都打断点 - 想查看局部代码是如何一步一步执行的。
哪里不会点哪里。
2，运行Debug
右键空白处，点击Debug运行模式就可以了
3，看哪里
看下面的debugger界面还有控制台界面。
控制台：输出语句。
键盘录入。
debugger界面：进入下一步。
查看程序运行过程中，变量里面值的变化情况。
4，进入下一步
建议大家，是按快捷键 F7
或者是点击 Step into
每点击一下，程序就执行一行。
5，结束Debug
点击左侧的红色方块。
6，取消断点
- 如果断点比较少。可以在代码区域直接点击红色大点取消。
- 如果断点比较多。可以点击控制台左侧，多个断点叠加的小图案进行取消。
