JavaSE学习day5_02, 方法重载（重点）

6. 方法重载

6.1 方法重载

• 方法重载概念

  方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

  • 多个方法在同一个类中

  • 多个方法具有相同的方法名

  • 多个方法的参数不相同，类型不同或者数量不同，包括参数个数，参数类型，和参数顺序不同。

• 注意：

  • 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式

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

• 正确范例：

  public class MethodDemo {
      public static void fn(int a) {
          //方法体
      }
      public static int fn(double a) {
          //方法体
      }
  }
  ​
  public class MethodDemo {
      public static float fn(int a) {
          //方法体
      }
      public static int fn(int a , int b) {
          //方法体
      }
  }

• 错误范例：

  public class MethodDemo {
      public static void fn(int a) {
          //方法体
      }
      public static int fn(int a) {   /*错误原因：重载与返回类型无关*/
          //方法体
      }
  }
  ​
  public class MethodDemo01 {
      public static void fn(int a) {
          //方法体
      }
  } 
  public class MethodDemo02 {
      public static int fn(double a) { /*错误原因：这是两个类的两个fn方法*/
          //方法体
      }
  }

6.2 方法重载练习

看几个习题：判断下面方法是不是重载

这几个题都能弄懂的话，说明方法重载没啥问题了。强调一下第四个，因为是在不同的类中，因此不是方法重载。重载有一个前提是在同一个类中。

• 需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）

• 思路：

  • ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数

  • ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数

  • ③定义所有的重载方法，两个byte类型与两个short类型参数

  • ④完成方法的调用，测试运行结果

• 代码：

  public class MethodTest {
      public static void main(String[] args) {
          //调用方法
          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));
      }
  ​
      //int
      public static boolean compare(int a, int b) {
          System.out.println("int");
          return a == b;
      }
  ​
      //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;
      }
  ​
      //long
      public static boolean compare(long a, long b) {
          System.out.println("long");
          return a == b;
      }
  }

7. 方法的参数传递

7.1 方法参数传递基本类型

• 测试代码：

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

• 结论：

  • 基本数据类型的参数，形式参数的改变，不影响实际参数

• 结论依据：

  • 每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

7.2 方法参数传递引用类型

• 测试代码：

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

• 结论：

  • 对于引用类型的参数，形式参数的改变，影响实际参数的值

• 结论依据：

  • 引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

7.3 数组遍历

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

• 思路：

  • ①因为要求结果在一行上输出，所以这里需要在学习一个新的输出语句System.out.print(“内容”);

    System.out.println(“内容”); 输出内容并换行

    System.out.print(“内容”); 输出内容不换行

    System.out.println(); 起到换行的作用

  • ②定义一个数组，用静态初始化完成数组元素初始化

  • ③定义一个方法，用数组遍历通用格式对数组进行遍历

  • ④用新的输出语句修改遍历操作

  • ⑤调用遍历方法

• 代码：

  public class Test1 {
      public static void main(String[] args) {
        /*  //先打印数据，再进行换行
          System.out.println("aaa");
          //只打印不换行
          System.out.print("bbb");
          System.out.print("ddd");
          //不打印任何内容，只换行
          System.out.println();
          System.out.print("cc");*/
          //设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55]
          int[] arr = {1,2,3,4,5};
          printArr(arr);
      }
      //1.我要遍历数组
      //2.需要什么？  数组
      //3.调用处是否需要使用方法的结果。
      public static void printArr(int[] arr){
          System.out.print("[");
          for (int i = 0; i < arr.length; i++) {
              if(i == arr.length - 1){
                  System.out.println(arr[i] + "]");
              }else{
                  System.out.print(arr[i] + ", ");
              }
          }
      }
  }

7.4 数组最大值

• 需求：设计一个方法用于获取数组中元素的最大值

• 思路：

  • ①定义一个数组，用静态初始化完成数组元素初始化

  • ②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了

  • ③调用获取最大值方法，用变量接收返回结果

  • ④把结果输出在控制台

• 代码：

  public class MethodTest02 {
      public static void main(String[] args) {
          //定义一个数组，用静态初始化完成数组元素初始化
          int[] arr = {12, 45, 98, 73, 60};
  ​
          //调用获取最大值方法，用变量接收返回结果
          int number = getMax(arr);
  ​
          //把结果输出在控制台
          System.out.println("number:" + number);
      }
  ​
      //定义一个方法，用来获取数组中的最大值
      /*
          两个明确：
              返回值类型：int
              参数：int[] arr
       */
      public static int getMax(int[] arr) {
          int max = arr[0];
  ​
          for(int x=1; x<arr.length; x++) {
              if(arr[x] > max) {
                  max = arr[x];
              }
          }
          return max;
      }
  }

注意：数组使用有两点需要注意：

7.5 判断是否存在

需求：

​ 定义一个方法判断数组中的某一个数是否存在，将结果返回给调用处

代码示例：

  public class Test3 {
      public static void main(String[] args) {
          //定义一个方法判断数组中的某一个数是否存在，将结果返回给调用处
  
          int[] arr = {1,2,3,4,5};
          boolean result = contains(arr, 3);
          System.out.println(result);
      }
  
      //1. 我要干嘛？判断数组中的某一个数是否存在
      //2. 需要什么？数组 数字
      //3. 调用处是否需要继续使用？返回
      //判断number在arr中是否存在
      public static boolean contains(int[] arr, int number) {//1 2 3 4 5    6
          //遍历arr得到每一个元素
          for (int i = 0; i < arr.length; i++) {
              //拿着每一个元素跟number比较
              if(arr[i] == number){
                  //如果相等，表示存在
                  return true;
              }
          }
          //当循环结束之后，如果还不能返回true，表示数组中所有数据都不相等
          //可以返回false
          return false;
      }
  }
  

自动生成方法返回值的变量快捷键：ctrl+alt+V，就是如下：

当我们写add(3,4)此时，光标点一下这个语句，再按住这个快捷键：ctrl+alt+V就会自动生成如下语句：

此时再修改一下变量名就可以了，比较方便，最好对这些快捷键有些印象。

7.6 获取索引

需求：

定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处，如果有重复的，只要获取第一个即可。

代码示例：

package com.itheima.demo;
​
public class Test4 {
    public static void main(String[] args) {
        //定义一个方法获取数字，在数组中的索引位置，将结果返回给调用处
        //如果有重复的，只要获取第一个即可
​
        int[] arr = {1,2,3,4,5};
        int index = contains(arr, 3);
        System.out.println(index);
    }
​
    //1. 我要干嘛？判断数组中的某一个数是否存在
    //2. 需要什么？数组 数字
    //3. 调用处是否需要继续使用？返回
    //获取number在arr中的位置
    public static int contains(int[] arr, int number) {
        //遍历arr得到每一个元素
        for (int i = 0; i < arr.length; i++) {
            //拿着每一个元素跟number比较
            if(arr[i] == number){
                //如果相等，表示找到了
                return i;
            }
        }
        //当循环结束之后，如果还不能返回索引，表示数组中不存在该数据
        //可以返回-1
        return -1;
    }
}
​

7.7 复制数组

需求：

定义一个方法copyOfRange(int[] arr,int from, int to)

功能：

将数组arr中从索引from（包含from）开始。

到索引to结束（不包含to）的元素复制到新数组中，
​
将新数组返回。

代码示例：

package com.itheima.test;
​
public class Test4 {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] newArr = copyOfRange(arr, 3, 9);// [3索引~ 9索引)
​
        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }
    }
    //如果方法要返回多个值，那么只能以数组的形式进行返回
    //把arr数组中，从from开始，到to之间的数据进行返回
    //{1,2,3,4,5,6,7,8,9,10}
​
    //技巧：(伪造索引)
    //在代码中，如果没有一个变量能表示当前的索引
    //就自己新建一个变量表示索引
​
    public static int[] copyOfRange(int[] arr, int from,int to){
        //1.新建一个新的数组
        int[] newArr = new int[to - from];
​
        int index = 0;
        //2.获取老数组中，from到to之间所有的元素
        for (int i = from; i < to; i++) {
            //System.out.println(arr[i]);
            //数组名[索引] = 数据值;
            //这是我想要的效果：在赋值的时候从newArr的0索引开始，依次往后赋值
            newArr[index] = arr[i];
            index++;
        }
​
        //当循环结束之后，表示新数组中已经存满元素了
        return newArr;
    }
}

注意：返回类型为一个数组类型的方法怎么写，我们和C语言相区别。在C语言中我们使用数组指针返回的。和java是不同的。

回顾：