Java入门到精通:第九课 方法（二）

一、方法的重载

1、概念：

java虚拟机会通过参数的不同来区分同名的方法

2、区分以下方法是否构成重载

思路：是否在一个类？方法名是否相同？参数是否一样？

注意：

3、练习：

使用方法重载，来比较两个整数是否相同的方法。要求兼容全整数类型（byte,short,int,long）

示例代码：

package MethodDemo;

public class MethodDemo6 {
    public static void main(String[] args) {
        //使用方法重载，来比较两个整数是否相同的方法。
        // 要求兼容全整数类型（byte,short,int,long）

        //调用：
        //compare(10,20);

        //compare((byte) 10,(byte) 20);
        //整数默认为int类型，所以要进行强制类型转换，转为byte

        //最常用的方式：
        /*byte b1 = 10;
        byte b2 = 20;
        compare(b1, b2);
         */

        long n1 = 10;
        long n2 = 20;
        compare(n1,n2);

        //idea的特性：没有调用的方法名为灰色，调用的为彩色
    }
    //把相同功能的方法名起一样的
    //好处1：定义方法的时候可以不用这么多的单词；
    //好处2：调用方法的时候也不需要那么麻烦了。
    public static void compare(byte b1 , byte b2) {
        System.out.println("byte");
        System.out.println(b1 == b2);
    }

    public static void compare(short s1 , short s2) {
        System.out.println("short");
        System.out.println(s1 == s2);
    }

    public static void compare(long n1 , long n2) {
        System.out.println("long");
        System.out.println(n1 == n2);
    }
}

运行结果：

二、方法的应用

1、数组遍历

设计一个方法用于数组遍历，要求遍历的结果是在一行上的。【例如[11，22，33，44，55]】

示例代码：

package test;

public class test8 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {11,22,33,44,55};

        //2.调用方法遍历数组
        printArr(arr);

        /*System.out.println("abc");//先打印abc,再进行换行
        System.out.print("abc");//只打印abc,不换行
        System.out.print("bcd");
        System.out.println();//不打印任何数据，只做换行处理
         */
    }

    //定义方法用于数组的遍历
    //1.我要干嘛？遍历数组
    //2.需要什么？ 数组
    //方法的调用处是否需要继续使用结果？ 不需要返回值
    public static void printArr(int[] arr) {
        System.out.print("[");
        for(int i = 0; i < arr.length; i++) {
            if(i == arr.length - 1){
            System.out.print(arr[i]);
            } else {
                System.out.print(arr[i] + ",");
            }

        }
       System.out.print("]");
    }
}

运算结果：

2、求数组最大值，并将最大值返回

示例代码：

package test;

public class test9 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {1,5,7,3,8,9,10};

        //2.调用方法求最大值
        int max = getMax(arr);

        //3.打印
        System.out.println(max);
    }
    //1.我要干嘛？ 求最大值
    //2.需要什么？ 数组
    //3.是否需要返回值？ 需要
    public static int getMax(int[] arr) {
      int max = arr[0];

      for (int i = 1; i < arr.length; i++) {
          if (arr[i] > max){
              max = arr[i];
          }
      }
      return max;
    }

}

运算结果：

3、判断数字在数组中是否存在，将结果返回给调用处

示例代码：

package test;

public class test10 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr = {11,22,33,44,55,66,77,88};

        //2.判断一个数字在数组中是否存在
        boolean flag = contains(arr, 89);

        //3.打印
        System.out.println(flag);


    }

    //1.我要干嘛？判断一个数字在数组中是否存在
    //2.需要什么？ 数组，目标数字
    //3.返回结果？ 返回 true false
    public static boolean contains(int[] arr,int number) {
        //查找89是否存在
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number) {
                return true;
            }

        }
        //当数组里所有的数据全部比较完毕之后，才能断定数字89是否存在
        //所以要写在for循环外
        return false;
    }
}

//return break关键字的区别
//return：其实跟循环没有什么关系，跟方法有关，表示结束方法，返回结果
//如果方法执行到了return，那么整个方法全部结束，里面的循环也随之结束

//break 关键字
//与方法无关，是结束循环或者结束switch。

运算结果：

4、复制数组：数组arr从索引from开始，到索引to结束

难点：伪造索引思想 （index）

数组名[索引] = 数据值

示例代码：

package test;

public class test11 {
    public static void main(String[] args) {
        /*题目：定义一个方法copyOfRange(int[] arr, int from, int to)
         *功能：
         * 将数组arr中从索引from开始，到索引to结束的元素（不包含to）复制到新的数组中
         * 将新数组返回
         */

        //1.定义原始数组arr
        int[] arr = {1,2,3,4,5,6,7,8,9};

        //2.调用方法来拷贝数据
        int[] copyArr = copyOfRange(arr,3,7);

        //3.遍历copyArr
        for (int i = 0; i < copyArr.length; i++) {
            System.out.println(copyArr[i] + "");
        }
    }

    //将数组arr中从索引from开始，到索引to结束的元素（不包含to）复制到新的数组中
    public static int[] copyOfRange(int[] arr, int from, int to) {
        //1.定义数组
        //静态：知道所有元素
        //动态：不知道所有元素[to - from]
        int[] newArr = new  int[to - from];
        //2.将数组arr中索引from到to对应的元素复制到新的newArr中

        //伪造索引思想：
        int index = 0;
        for (int i = from; i < to;i++) {
            //格式： 数组名[索引] = 数据值；
            newArr[index] = arr[i];
            index++;
        }
        //3.把数组返回
        return newArr;
    }

运算结果：

三、方法的内存

1、方法调用的基本内存原理

方法的存储方式：栈

2、方法传递基本数据类型的内存原理

传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值

变量中存储的是真实的数据

示例代码：

/*package MethodDemo;

public class MethodDemo7 {
    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 MethodDemo;

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

运算结果：

3、方法传递引用数据类型的内存原理

传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值

 变量中存储的是地址值

示例代码：

public class MethodDemo8 {
    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;
    }
}

运行结果：

 4、总结：

5、方法参数传递的结论