1.9 -方法重载、Debug调试

最新推荐文章于 2021-08-07 17:11:34 发布

Joker_Demon

最新推荐文章于 2021-08-07 17:11:34 发布

阅读量217

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_45689417/article/details/107100978

版权

Java 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1.9 -方法重载、Debug调试

1 方法重载

1.1 方法重载（理解）

方法重载概念
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
多个方法在同一个类中
多个方法具有相同的方法名
多个方法的参数不相同，类型不同或者数量不同

注意：

重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回
值来判定两个方法是否相互构成重载

正确范例：

package Demo02;

public class MethodDemo01 {
    public static void main(String[] args) {
        fn();
        fn(1000);
        fn(10.11);
    }
    
    public static void fn() {
        // 方法体
    }
    
    public static void fn(int a) {
        // 方法体
    }

    public static void fn(double a) {
        // 方法体
    }
}

1.2 方法重载练习（掌握）

**需求：**使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型
（byte,short,int,long）
思路：
①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
③定义所有的重载方法，两个byte类

package Demo02;

public class MethodDemo02 {
    public static void main(String[] args) {
        // 使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型
        // （byte,short,int,long）
        //调用方法
        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));
    }

    // 方法
    public static boolean compare(int a, int b) {
        return a == b;
    }

    public static boolean compare(byte a, byte b) {
        return a == b;
    }

    public static boolean compare(short a, short b) {
        return a == b;
    }

    public static boolean compare(long a, long b) {
        return a == b;
    }
}

2 方法的参数传递

2.1 方法参数传递基本类型（理解）

测试代码：

package Demo02;

public class MethodDemo03 {
    public static void main(String[] args) {
        int number = 100;
        System.out.println("调用change方法前：" + number);	// 100
        change(number);
        System.out.println("调用change方法后：" + number);	// 100
    }
    public static void change(int number) {
        number = 200;
    }
}

**结论：
**基本数据类型的参数，形式参数的改变，不影响实际参数
结论依据：
每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RyOEachy-1593744405487)(C:\Users\Data\AppData\Roaming\Typora\typora-user-images\image-20200703095909404.png)]

2.2 方法参数传递引用类型（理解）

测试代码

package Demo02;

public class MethodDemo04 {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30};
        System.out.println("调用change方法前：" + arr[1]);    // 20
        change(arr);
        System.out.println("调用change方法后：" + arr[1]);    // 200
    }
    public static void change(int[] arr) {
        arr[1] = 200;
    }
}

结论：
对于引用类型的参数，形式参数的改变，影响实际参数的值
结论依据：

引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所

以即使方法弹栈，堆内存中的数据也已经是改变后的结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SEfPvH0q-1593744405490)(C:\Users\Data\AppData\Roaming\Typora\typora-user-images\image-20200703100210353.png)]

2.3 数组遍历（应用）

需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
思路：
①因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);
System.out.println(“内容”); 输出内容并换行
System.out.print(“内容”); 输出内容不换行
System.out.println(); 起到换行的作用
②定义一个数组，用静态初始化完成数组元素初始化
③定义一个方法，用数组遍历通用格式对数组进行遍历
④用新的输出语句修改遍历操作
⑤调用遍历方法
代码：

package Demo02;

public class MethodDemo05 {
    public static void main(String[] args) {
        // 需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
        int[] arr = {11, 22, 33, 44, 55};
        MethodArray(arr);
    }

    public static void MethodArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == arr[arr.length - 1]) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

2.4 数组最大值（应用）

需求：设计一个方法用于获取数组中元素的最大值
思路：
①定义一个数组，用静态初始化完成数组元素初始化
②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了
③调用获取最大值方法，用变量接收返回结果
④把结果输出在控制台
代码：

package Demo02;

public class MethodDemo06 {
    public static void main(String[] args) {
        // 需求：设计一个方法用于获取数组中元素的最大值
        int[] arr = {1, 11, 23, 3, -1};
        int max = getMax(arr);
        System.out.println(max);    // 23
    }

    public static int getMax(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            max = max > arr[i] ? max : arr[i];
        }
        return max;
    }
}

3.Debug模式

3.1什么是Debug模式【理解】

是供程序员使用的程序调试工具，它可以用于查看程序的执行流程，也可以用于追踪程序执行过程来调
试程序。

3.2Debug模式操作流程【应用】

如何加断点 :

----Debug 可以百度相关教程，较为详细。

扩展题目：

1 目标: 交换数组的0索引和最后一个索引的元素
原数组: {11, 22, 33, 44, 55}

交换后: {55, 22, 33, 44, 11}

package Demo02;

public class MethodDemo07 {
    public static void main(String[] args) {
        /*
        1 目标: 交换数组的0索引和最后一个索引的元素
            原数组: {11, 22, 33, 44, 55}
          交换后: {55, 22, 33, 44, 11}
         */
        int[] arr = {11, 22, 33, 44, 55};

        int a = arr[0];
        int b = arr[arr.length -1];
        
        arr[0] = b;
        arr[arr.length - 1] = a;

        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

2 目标: 完全置换数组的元素
原数组: {11, 22, 33, 44, 55}

交换后: {55, 44, 33,22, 11}

package Demo02;

public class MethodDemo08 {
    public static void main(String[] args) {
        /*
            2 目标: 完全置换数组的元素
            原数组: {11, 22, 33, 44, 55}
          交换后: {55, 44, 33,22, 11}
         */
        int[] arr = {11, 22, 33, 44, 55};
        int[] arr1 = arrayDemo(arr);
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }

        System.out.println();
        int[] array = {11, 22, 33, 44, 55};
        int[] arr2 = arrayDemo(array);
        for (int i = 0; i < arr2.length; i++) {
            System.out.print(arr2[i] + " ");
        }
    }

    // 方法1 完全替换成新的
    public static int[] arrayDemo(int[] arr) {
        int[] arr1 = new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            arr1[arr.length-(i+1)] = arr[i];
        }
        return arr1;
    }

    // 方法2 内容调换
    public static int[] arrayDemo2(int[] arr) {
        for (int i = 0; i < arr.length/2; i++) {
            int num1 = arr[i];
            int num2 = arr[arr.length - (i+1)];
            arr[i] = num2;
            arr[arr.length - (i+1)] = num1;
        }
        return arr;
    }
}

3 特殊知识位运算

package Demo02;

public class MethodDemo09 {
    public static void main(String[] args) {
// ^(异或)相同为false(0),不同为true(1)    true ^ true = false      false ^ true = true
        // 计算机中都是操作二进制
        // 数字可以按位异或,将整数转成二进制
        int a = 97; // 110 0001
        int b = 5;  // 000 0101
        //          ---------------
        //      100    110 0100
        //       5  ^  000 0101
        //         ---------------
        //       97 ^  110 0001
        //      一个数异或另一个数两次会等于这个数本身(加密)

        int c = a ^ b;
        int d = a ^ b ^ b;
        System.out.println(c);
        System.out.println(d);


        int x = 4;  // 100
        // >> (右移)让这个数字除以2
        System.out.println(x >> 1); // 2
        /*
         ******      右移一位******
         * 100*              *  10*
         ******              ******
         */

        // << (左移)让这个数字乘以2
        System.out.println(x << 1);
        /*
         ******      左移一位******
         * 100*              *1000*
         ******              ******
         */
    }
}
em.out.println(x >> 1); // 2
        /*
         ******      右移一位******
         * 100*              *  10*
         ******              ******
         */

        // << (左移)让这个数字乘以2
        System.out.println(x << 1);
        /*
         ******      左移一位******
         * 100*              *1000*
         ******              ******
         */
    }
}