JAVA入门基础（九）—— 方法的重载、Debug

---

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，取消断点

• 如果断点比较少。可以在代码区域直接点击红色大点取消。
• 如果断点比较多。可以点击控制台左侧，多个断点叠加的小图案进行取消。