05_方法和数组

Day05笔记
课程内容
1、方法
2、数组
方法
方法的概述
1、概念：
     有些代码表示一个独立的功能，这个功能还经常使用，那么就把这段代码用大括号{}包起来，给这个代码起一个名字，将来只要写这个名字，就表示要调用这段代码。这段代码就是一个方法。
2、定义格式：
     修饰符 返回值类型 方法名称 (参数列表) {
          方法体语句;
          return语句;
}
3、相关概念的解释：
     1、修饰符：描述方法的权限、静态、抽象。当前阶段全部都是public static
     2、返回值类型：
          当前方法生产出来的数据的数据类型
     3、方法名称：
          将来用于表示这段代码，一旦写出了方法名称，就表示要执行这段代码
          第一个单词的首字母小写，从第二个单词开始，首字母大写
一般定义成一个动词或者动宾结构
     4、参数列表：
          表示这段代码在完成功能的过程中，需要获取的外界的资源
          在定义方法的时候，参数列表指的是：形式参数，只是表示一个不知道的数据
          声明参数的格式：数据类型1 变量名1, 数据类型2 变量名2
     5、方法体语句：
          真正要经常使用的代码，表示这段代码的真正功能和逻辑，表示真正完成这个功能        使用的代码
     6、return语句：
          这段代码最终生产出来的结果，结果数据的数据类型应该和返回值类型一致
          return也表示当前方法结束
4、调用格式：
     方法名称(实际参数);
5、方法调用内容解释：
     1、方法名称：
          不是定义方法，所以不需要写方法的返回值类型
     2、实际参数：
          真正确定方法中需要使用的资源，传入的是真正的数据（就一定是有初始化过的变        量或者是常量）
代码示例
class Demo01_方法定义 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
        //盖饭 gf = 做饭(烂白菜, 镉大米, 地沟油);
        int a = 10;
        int b = 20;
        int sum = getSum(a, b);
        System.out.println(sum);
    }

    /*定义一个做饭的方法
    public static 盖饭 做饭(菜 c, 米 m, 油 y) {
        y热了
        c放入已经热了的y中
        对c进行搅拌
        把m蒸熟
        将熟了的c放到蒸熟的m上

        return cm;
    }
    */

    //定义求和的方法，可以计算两个数字的和
    //返回值类型：int，两个整数求和，结果还是一个整数
    //参数列表：int a, int b
    public static int getSum(int a, int b) {
        int sum = a + b;
        return sum;
    }
}
方法的注意事项
1、调用的注意事项：方法定义出来之后，不调用就不会执行
     单独调用：不对方法进行输出、也不使用一个变量来接收方法的返回值，只是单独的对方法进行调用。方法只是完成某些功能，没有什么具体产出。
     输出调用：有返回内容的方法，可以进行输出调用。在输出语句中，输出的内容是一个方法的调用。其实输出的是这个方法的返回值。（只能对返回内容输出一次）
     赋值调用：有返回内容的方法，可以使用一个变量，接收方法的返回值。可以对这个变量反复使用。
2、方法定义注意事项：
     1、方法不能嵌套定义，但是可以相互调用，甚至可以自己调用自己
     2、方法和方法都是平级关系
3、参数列表：
     1、形式参数：表示将来要使用的那个数据，但是现在不清楚数据具体内容，所以使用一个变量来表示。需要加上数据类型（其实是对变量的声明），变量和变量之间使用逗号进行分割。
     2、实际参数：表示在方法调用时，真正使用的那个数据。（本质是对变量的赋值和使用）。不需要加上数据类型，参数和参数之间使用逗号分割。
4、return语句：
     1、表示方法结束，用于表示方法返回内容
     2、如果方法有具体的返回内容，那么就必须有return语句，return后面就必须跟上一个具体的数据，这个数据的数据类型必须和方法声明中的返回值类型一致。
     3、如果方法没有具体的返回内容，那么就可以不写return语句，如果一定要写上return语句，可以写一个【return;】，用于表示方法结束。如果写的是return；或者是没写return语句，那么方法的返回值类型必须是void，表示没有任何返回内容
     4、返回值：一定是返回给方法的调用者。
代码示例
class Demo02_方法的注意事项 {
    public static void main(String[] args) {
        //直接调用
        printHL();
        //System.out.println(printHL());
        //输出调用
        System.out.println(getMax(10, 20));
        //赋值调用
        int max = getMax(10, 20);
        System.out.println(max);
    }

    //打印5次HelloWorld
    public static void printHL() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("HelloWorld");
        }
        return;
    }

    //两个数据获取较大值方法
    public static int getMax(int a, int b) {
        int max = a > b ? a : b;
        return max;
    }
    /*打印25次HelloWorld
    public static void print() {
        //编译报错，方法不能嵌套定义
        public static void print5() {
        
        }

        print5
    }
    */
}
练习1
定义一个方法，可以获取三个整数的最大值
键盘录入三个整数，调用方法，获取最大值
代码示例
import java.util.Scanner;
class Demo03_方法练习获取最值 {
    /*
    定义一个方法，可以获取三个整数的最大值
    键盘录入三个整数，调用方法，获取最大值
    */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        int z = sc.nextInt();
        int max = getMax(x, y, z);
        System.out.println("最大值为：" + max);
    }

    //获取三个整数最大值的方法，返回值类型int，参数列表int a, int b, int c
    public static int getMax(int a, int b, int c) {
        if (a > b && a > c) {
            return a;
        } else if ( b > a && b > c) {
            return b;
        } else {
            return c;
        }

        /*
        int max = a > b ? (a > c ? a : c) : (b > c ? b : c);
        return max;
        */
    }
}
练习2
定义一个方法，判断两个整数是否相等
键盘录入两个整数，调用方法，判断是否相等
代码示例
import java.util.Scanner;
class Demo04_方法练习判断相等 {
    /*
    定义一个方法，判断两个整数是否相等
    键盘录入两个整数，调用方法，判断是否相等
    */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        int y = sc.nextInt();
        boolean result = isEqual(x, y);
        System.out.println("这两个数字" + (result ? "" : "不") + "相等");
    }

    /*
        定义一个方法，判断两个整数是否相等
        返回值类型：boolean
        参数列表：int a, int b
    */
    public static boolean isEqual(int a, int b) {
        /*if (a == b) {
            return true;
        } else {
            return false;
        }

        return a == b ? true : false;*/

        return a == b;
    }
}
练习3
定义一个方法，可以打印指定行数和列数的星星矩形
键盘录入两个整数，分别表示行数和列数，调用方法，打印矩形
代码示例
import java.util.Scanner;
class Demo05_方法练习打印矩形 {
    /*
    定义一个方法，可以打印指定行数和列数的星星矩形
    键盘录入两个整数，分别表示行数和列数，调用方法，打印矩形
    */
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int row = sc.nextInt();
        int col = sc.nextInt();
        printRect(row, col);
    }
    /*
        返回值类型：void，打印不是返回值
        参数列表：int row, int col
    */
    public static void printRect(int row, int col) {
        for (int i = 1; i <= row; i++) {
            //打印col个星星
            for(int j = 1; j <= col; j++) {
                System.out.print("*");
            }
            //加一个换行
            System.out.println();
        }
    }
}
方法在内存中的情况
Jvm虚拟机的内存划分
1、jvm是运行java代码的容器，需要分成一些不同的区域，不同的区域有不同的特殊作用。
2、区域的说明：
     1、栈内存：先进后出，对于方法先进后出。作用：执行方法的。【常用】
     2、堆内存：用于存储数据量较大的数据。比如数组、对象【常用】
     3、方法区：用于存储类的字节码对象，存储一些静态变量，存储常量【常用】
     4、本地方法区：和本地方法相关，在java代码中，有一些要和C语言代码交互的方法，称为本地方法，加上native关键字的就是本地方法。
     5、寄存器：和cpu有关，用于控制代码的执行流程，和程序计数器有关。
方法调用时内存描述
1、方法调用的步骤
     1、启动jvm虚拟机之后，默认调用main方法，就会在栈内存中，开辟一块空间，专门用于主方法中变量的声明和计算，形象的称为“方法进栈”，这个专门用于执行当前方法的区域，称为“栈帧”
     2、主方法中调用了其他的方法，在主方法不出栈的前提下，其他方法进栈，主方法将自己的一些数据传递给被调用的方法，被调用方法，执行完成之后，将结果返回给主方法，被调用的方法出栈
     3、继续执行主方法
2、图示：
     
方法的重载
1、没有方法重载的时候：
     很多方法，逻辑相似的，但是参数列表是不同的，就需要有很多的方法名称。
     调用者（程序员）需要记忆很多的方法名称，就非常不方便。
     希望逻辑相似的代码，参数不同的方法，可以使用相同的方法名称。
2、方法重载：
     定义：在同一个类中，方法名相同，参数列表不同，与返回值类型无关【记忆】
     名称：重载，overload，超载
3、注意事项：
     1、在同一个类中，不能是无关类、也不能是子父类，必须是同一个类
     2、方法名称相同：连大小写都必须一模一样
     3、参数列表不同：
          参数的数据类型不同
          参数的个数不同
          参数的数据类型的顺序不同
          【注意】参数的名称不同，不能认为成参数列表不同，而是参数列表相同
     4、与返回值类型无关：调用方法的时候，无法判断需要什么返回值类型，所以相同方法名称，相同的参数列表，不同的返回值类型，对于虚拟机而言，没有任何区别，无法区分到底应该调用哪个方法
代码示例
class Demo06_方法的重载 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 30;
        /*System.out.println(getSum2(a, b));
        System.out.println(getSumD2(12.34, 43.21));
        */
        System.out.println(getSum(a, b));
        System.out.println(getSum(1, 2, 3));
        System.out.println(getSum(12.34, 43.21));
        
        System.out.println(getSum(1, 2.0));
        System.out.println(getSum(1.0, 2));


    }
    /*
    public static double getSum(int a, int b) {
        return a + b;
    }

    定义方法，计算int和double的和
    public static double getSum(int i, double d) {
        return i + d;
    }*/

    //定义方法，计算int和double的和
    public static double getSum(int a, double b) {
        System.out.println("int + double 被调用了");
        return a + b;
    }

    //定义方法，计算double和int的和
    public static double getSum(double a, int b) {
        System.out.println("double + int 被调用了");
        return a + b;
    }

    //定义方法，计算两个int的和
    public static int getSum(int a, int b) {
        return a + b;
    }
    //定义方法，计算三个int类型的和
    public static int getSum(int a, int b, int c) {
        return a + b + c;
    }
    //定义方法，计算两个double的和
    public static double getSum(double a, double b) {
        return a + b;
    }

    /*
    //定义一个方法，计算两个int类型数据的和
    public static int getSum2(int a, int b) {
        return a + b;
    }

    //定义一个方法，计算三个int类型数据的和
    public static int getSum3(int a, int b, int c) {
        return a + b + c;
    }

    //定义一个方法，计算两个double类型数据的和
    public static double getSumD2(double a, double b) {
        return a + b;
    }
    */
}
数组
数组的概述
1、数组：用于存储相同数据类型的数据的，容器
2、使用数组的原因：
     如果没有数组，所有的变量都需要使用变量名称，变量名称过多的时候，就不方便操作，变量和变量之间，没有关系，没有固定的规律。
     数组的解决方案：只需要有一个容器的名称，容器中每个位置都有自己的序号，元素存储进来之后，就可以通过【容器名称 + 元素序号】来获取和修改这个位置的元素。本质：就是通过有规律的序号，访问没有规律的元素内容。
3、数组的定义方式：
     元素的数据类型[] 数组名称 = new 元素的数据类型[数组的大小];
4、数组的定义解释：
     元素的数据类型：在数组中有数据，就称为元素，数据的类型就是元素类型
     []：表示当前数组是一个一维数组
     数组的名称：数组本身也是一个变量，有自己的变量名称
     =：赋值符号，将=后面创建出来的数组的地址，赋值给=前面的变量
     new：在堆内存中开辟一块存储空间
     数组的大小：数组是一个容器，有存储的空间，能存储多少数据，数组的大小就是多少
5、打印内容的解释：[I@15db9742
     1、[：表示一个一维数组
     2、I：表示数组中存储的数据类型是int
     3、@：表示一个普通的分隔符
     4、15db9742：数组有一个内存地址，通过hashCode方法，将内存地址计算成一个数字，称为哈希码值，转成十六进制，15db9742
     说明：简称这个打印的内容为：数组的内存地址
代码示例
class Demo07_数组的定义 {
    public static void main(String[] args) {
        //定义一个int类型的数组
        int[] arr = new int[3];
        System.out.println(arr);
    }
}
数组的初始化
1、初始化：给数组的数据分配内存空间，并且给元素赋值
2、分类：动态初始化、静态初始化
3、动态初始化：
     元素的数据类型[] 数组名称 = new 元素的数据类型[数组中元素的个数]
     数组中的元素赋值：
          数组名称[元素的索引] = 元素值;
     注意事项：
           1、所有的元素，都需要使用这个格式来一一赋值
          2、元素的索引：从0开始，到元素个数-1结束
          3、如果没有给元素赋值，那么数组的元素有一个默认的初始化值，0
4、静态初始化：
     元素的数据类型[] 数组名称 = new 元素的数据类型[]{元素值的罗列}
     注意事项：
          1、在后面的方括号中，不要写任何元素个数
          2、元素值的罗列，使用逗号分割
          3、罗列的元素，数据类型必须和声明中的元素数据类型一致
          4、静态初始化有一个简写的格式【常用】
               元素的数据类型[] 数组名称 = {元素值的罗列};
               这种写法，不能将数组的声明和数组的赋值分离开
代码示例1
class Demo08_数组的动态初始化 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        //默认的初始化值
        System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        arr[0] = 10;
        arr[1] = 20;
        arr[2] = 30;
        System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
    }
}
代码示例2
class Demo09_静态初始化 {
    public static void main(String[] args) {
        int[] arr = new int[]{10, 20, 30};
        System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        //编译报错，不能在静态初始化格式中，参与动态初始化的格式
        //int[] arr2 = new int[3]{10, 20, 30};
        //编译报错，后面的元素值，和声明不符
        //int[] arr3 = new int[]{12.34, 23.45, 43.21};

        int[] arr4 = {100, 200, 300};
        System.out.println(arr4[0] + "..." + arr4[1] + "..." + arr4[2]);


        int[] arr5;
        arr5 = new int[]{11, 22, 33};

        int[] arr6;
        arr6 = {666, 888};
    }
}
数组在内存中的理解
一个数组的内存图
1、创建数组在内存中的过程：
     1、在栈内存中声明一个引用，将来存储数组的地址
     2、在堆内存中开辟一块空间，存储元素
     3、给数组中的元素进行默认的初始化赋值，都变成了0
     4、将堆内存中的数组的地址，赋值给栈内存中的引用
2、图示：
   
3、代码示例
class Demo10_一个数组的内存图 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[1]);
        arr[1] = 666;
        System.out.println(arr[1]);
    }
}
两个数组的内存图
1、说明：
     只要碰到了new关键字，一定是要在堆内存中开辟一块新的空间
2、图示：
   
3、代码示例
class Demo11_两个数组的内存图 {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        arr1[1] = 666;
        int[] arr2 = new int[3];
        arr2[1] = 888;
        System.out.println(arr1[1] + "..." + arr2[1]);
    }
}
两个引用指向同一个数组
1、说明：
     两个引用中记录的是同一个数组的地址
     通过任意一个引用操作了数组中的内容，将来通过另一个引用找到数组之后，都是改变过的情况
2、图示：
   
3、代码示例
class Demo12_两个引用指向同一个数组 {
    public static void main(String[] args) {
        int[] arr1 = new int[3];
        arr1[1] = 666;
        int[] arr2 = arr1;
        arr2[1] = 888;
        System.out.println(arr1[1] + "..." + arr2[1]);
    }
}
数组的异常
异常
1、例外情况：代码中，程序中，出现了和生活中不太相符的情况，就是例外情况，将这种情况封装成一个对象，称为“异常对象”。有了异常之后，就可以结束程序或者跳转程序。
2、在数组操作过程中，经常出现的两个异常：
     数组索引越界异常
     空指针异常
数组索引越界异常
1、Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
     异常   在  线程  主          数组索引 超过了边界   异常：数组索引越界异常
2、原因：访问了数组中不存在的索引
3、避免：不要访问数组中不存在的索引
class Demo13_数组索引越界异常 {
    public static void main(String[] args) {
        int[] arr = {11, 33, 55};
        arr[0] = 666;
        arr[1] = 888;
        arr[2] = 999;
        arr[3] = -666;
    }
}
空指针异常
1、Exception in thread "main" java.lang.NullPointerException
     异常   在  线程  主             空   指针  异常：空指针异常
2、原因：
     栈内存中的引用，为空，不再指向任何堆内存中的数据，但仍然要强行访问堆内存中的数据。
3、指针：是C语言中的概念，指针类型的变量，存储的不是具体的数据，而是指的数据的地址。在java中已经不能直接操作内存地址，该这个指针类型为【引用类型】。空指针异常，其实就是空引用异常，都是表示无法获取数据的地址。
4、避免：在操作任何一个引用之前，可以先判断这个引用是否为null，如果为null，就不进行操作。
class Demo14_空指针异常 {
    public static void main(String[] args) {
        int[] arr = {11, 22, 33};
        System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        arr = null;
        if (arr != null) {
            System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
        }
    }
}
数组的操作
数组的遍历
1、遍历：把数组中的每个元素都获取出来，对每个元素进行输出
2、方法：获取到所有的元素的索引，根据索引获取到元素
3、索引范围：0~元素的个数-1
4、获取元素个数：数组名称.length
class Demo15_数组的遍历 {
    public static void main(String[] args) {
        int[] arr = {11, 33, 55, 22, -66};
        //遍历这个数组,获取所有的索引
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}
数组获取最值
1、数组中有若干元素，获取数组的最大值
2、声明一个最大值变量
数组的反转
1、数组中有若干元素，将第一个元素和最后一个元素交换，第二个元素和倒数第二个元素交换
数组的查找
1、数组中有若干元素，找到某个指定值，在数组中的索引