:victory::victory::victory::victory::victory::victory::victory::victory::victory::victory::victory:
15.函数（方法）
        （1）完成特定功能的代码块。
        （2）格式：
                        修饰符  返回值类型  函数名(形式参数 变量1, 形式参数 变量2...){
                                方法体;
                                return 返回值;
                        }
                        A：修饰符
                                public static
                        B：返回值类型
                                结果的数据类型。
                        C：方法名
                                方便调用
                        D：参数
                                形式参数：接收实际参数的变量
                                实际参数：实际参与运算的变量
                        E：方法体
                                就是按照正常的逻辑完成功能的代码。
                        F：return
                                方法的结果需要带回来。
                                用于结束方法。（void类型的方法，内部也有一个return;）
                        G：返回值
                                就是结果。
        （3）案例：
                        A：求两个int类型的数据之和。
                                public static int Sum(int a, int b){
                                        return a + b;
                                }
                        B：比较两个int类型的数据是否相等。
                                public static boolean Compare(int a, int b){
                                        if (a==b){
                                                return true;
                                        }
                                }
                        C：获取三个int类型数据中的最大值。
                                public static int getMax(int a, int b, int c){
                                        int max;
                                        int result = (a>b)? a : b;
                                        int result2 = (result > c) ? result : c;
                                        return result2;
                                }
        （4）注意：
                        A：函数只有被调用才执行。
                        B：函数之间是平级关系。
        （5）函数的调用：
                        A：void类型
                                单独调用。
                        B：非void类型
                                单独调用，没有意义。
                                输出调用，可能不好。
                                赋值调用，推荐方案。
        （6）函数重载：
                        函数名相同，参数列表不同（个数和类型）
                        与返回值无关。
16.数组
        （1）存储同一种数据类型的多个元素类型的容器。
        （2）特点：每一个元素都有编号，从0开始。
        （3）格式：
                A:int[] arr = new int[3];
                B:int[] arr = new int[]{1,2,3};
                C:int[] arr = {1,2,3};
                  System.out.println(arr.length);
                  System.out.println(arr[0]);
        （4）操作：
                A：遍历
                        public static void printArray(int[] arr){
                                for(int x=0; x<arr.length; x++){
                                        System.out.println(arr[x]);
                                }
                        }
                B：获取最值
                        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;
                        }
                C：排序
                        选择排序：
                                从0索引位置，依次和后面的元素进行比较。
                                第一次结束后，最小值出现在了0索引位置。
                                
                                public static void selectSort(int[] arr){
                                        for(int x=0; x<arr.length-1; x++){
                                                for(int y=x+1; y<arr.length; y++){
                                                        if(arr[y]>arr[x]){
                                                                int temp = arr[y];
                                                                arr[y] = arr[x];
                                                                arr[x] = temp;
                                                        }
                                                }
                                        }
                                }
                        
                        冒泡排序：
                                相邻元素两两比较，大的后放。
                                
                                public static void selectSort(int[] arr) {
                                        for(int x=0; x<arr.length-1; x++) {
                                                for(int y=0; y<arr.length-1-x; y++) {
                                                        if(arr[y]>arr[y+1]){
                                                                int temp = arr[y];
                                                                arr[y] = arr[y+1];
                                                                arr[y+1]= temp;
                                                        }
                                                }
                                        }
                                }
                D：查找
                        a：普通查找
                                针对数组没有顺序的情况。
                                public static int getIndex(int[] arr, int value){
                                        int index = -1;
                                        for(int x=0; x<arr.length; x++){
                                                if(value==arr[x]){
                                                        index = x;
                                                        break;
                                                }
                                        }
                                        return index;
                                }
                        b：二分查找
                                前提：数组必须有序。
                                public static int getIndex(int[] arr, int value){
                                        int min = 0;
                                        int max = arr.length - 1;
                                        int mid = (min+max) / 2;
                                        while(arr[mid]!=value){
                                                if(value>arr[mid]){
                                                        min = mid + 1;
                                                }else if{
                                                        max = mid - 1;
                                                }
                                                if(max<min){
                                                        return -1;
                                                }
                                                mid = (min+max) / 2;
                                        }
                                        return mid;
                                }
                E：Arrays工具类。
17：二维数组
        (1)任何数组都看成一维数组。
        (2)二维数组定义：
                A：int[][] arr = new int[2][3];
                B：int[][] arr = new int[2][];
                C：int[][] arr = {{1,2,3},{3,4,5},{6,7,9}};
        (3)二维数组的遍历：
                for(int x=0; x<arr.length; x++) {
                        for(int y=0; y<arr[x].length;y++){
                                System.out.print(arr[x][y]+" ")
                        }
                        System.out.println();
                }

:victory::victory::victory::victory::victory::victory::victory::victory::victory::victory::victory:
15.函数（方法）
        （1）完成特定功能的代码块。
        （2）格式：
                        修饰符  返回值类型  函数名(形式参数 变量1, 形式参数 变量2...){
                                方法体;
                                return 返回值;
                        }
                        A：修饰符
                                public static
                        B：返回值类型
                                结果的数据类型。
                        C：方法名
                                方便调用
                        D：参数
                                形式参数：接收实际参数的变量
                                实际参数：实际参与运算的变量
                        E：方法体
                                就是按照正常的逻辑完成功能的代码。
                        F：return
                                方法的结果需要带回来。
                                用于结束方法。（void类型的方法，内部也有一个return;）
                        G：返回值
                                就是结果。
        （3）案例：
                        A：求两个int类型的数据之和。
                                public static int Sum(int a, int b){
                                        return a + b;
                                }
                        B：比较两个int类型的数据是否相等。
                                public static boolean Compare(int a, int b){
                                        if (a==b){
                                                return true;
                                        }
                                }
                        C：获取三个int类型数据中的最大值。
                                public static int getMax(int a, int b, int c){
                                        int max;
                                        int result = (a>b)? a : b;
                                        int result2 = (result > c) ? result : c;
                                        return result2;
                                }
        （4）注意：
                        A：函数只有被调用才执行。
                        B：函数之间是平级关系。
        （5）函数的调用：
                        A：void类型
                                单独调用。
                        B：非void类型
                                单独调用，没有意义。
                                输出调用，可能不好。
                                赋值调用，推荐方案。
        （6）函数重载：
                        函数名相同，参数列表不同（个数和类型）
                        与返回值无关。
16.数组
        （1）存储同一种数据类型的多个元素类型的容器。
        （2）特点：每一个元素都有编号，从0开始。
        （3）格式：
                A:int[] arr = new int[3];
                B:int[] arr = new int[]{1,2,3};
                C:int[] arr = {1,2,3};
                  System.out.println(arr.length);
                  System.out.println(arr[0]);
        （4）操作：
                A：遍历
                        public static void printArray(int[] arr){
                                for(int x=0; x<arr.length; x++){
                                        System.out.println(arr[x]);
                                }
                        }
                B：获取最值
                        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;
                        }
                C：排序
                        选择排序：
                                从0索引位置，依次和后面的元素进行比较。
                                第一次结束后，最小值出现在了0索引位置。
                                
                                public static void selectSort(int[] arr){
                                        for(int x=0; x<arr.length-1; x++){
                                                for(int y=x+1; y<arr.length; y++){
                                                        if(arr[y]>arr[x]){
                                                                int temp = arr[y];
                                                                arr[y] = arr[x];
                                                                arr[x] = temp;
                                                        }
                                                }
                                        }
                                }
                        
                        冒泡排序：
                                相邻元素两两比较，大的后放。
                                
                                public static void selectSort(int[] arr) {
                                        for(int x=0; x<arr.length-1; x++) {
                                                for(int y=0; y<arr.length-1-x; y++) {
                                                        if(arr[y]>arr[y+1]){
                                                                int temp = arr[y];
                                                                arr[y] = arr[y+1];
                                                                arr[y+1]= temp;
                                                        }
                                                }
                                        }
                                }
                D：查找
                        a：普通查找
                                针对数组没有顺序的情况。
                                public static int getIndex(int[] arr, int value){
                                        int index = -1;
                                        for(int x=0; x<arr.length; x++){
                                                if(value==arr[x]){
                                                        index = x;
                                                        break;
                                                }
                                        }
                                        return index;
                                }
                        b：二分查找
                                前提：数组必须有序。
                                public static int getIndex(int[] arr, int value){
                                        int min = 0;
                                        int max = arr.length - 1;
                                        int mid = (min+max) / 2;
                                        while(arr[mid]!=value){
                                                if(value>arr[mid]){
                                                        min = mid + 1;
                                                }else if{
                                                        max = mid - 1;
                                                }
                                                if(max<min){
                                                        return -1;
                                                }
                                                mid = (min+max) / 2;
                                        }
                                        return mid;
                                }
                E：Arrays工具类。
17：二维数组
        (1)任何数组都看成一维数组。
        (2)二维数组定义：
                A：int[][] arr = new int[2][3];
                B：int[][] arr = new int[2][];
                C：int[][] arr = {{1,2,3},{3,4,5},{6,7,9}};
        (3)二维数组的遍历：
                for(int x=0; x<arr.length; x++) {
                        for(int y=0; y<arr[x].length;y++){
                                System.out.print(arr[x][y]+" ")
                        }
                        System.out.println();
                }