总结

方法

方法的组成：修饰符 + 返回值类型 + 方法名 + 形参列表 + 方法体
方法签名：方法名 + 形参列表
调用方法：方法有static修饰，调用是：类名.方法名();
调用方法使用参数是实际参数（必须是具体的数据）
在java里面用static修饰的方法叫做：类方法或者静态方法

形参和实参

声明方法使用参数是形参
调用方法使用参数是实参

1、传递参数（传参）
调用方法的时候传入参数（实参）
值传递：参数是基本数据类型，传参就是值传递
地址传递：参数是引用类型，就是是地址传递

2、方法重载（overload）
1)、为什么要使用方法重载
在java方法做同一类型事，方法的名字会有很多，不方便记忆，既然是同一类型业务，那么方法名字用同一个名，这样降低方法名的记忆成本

2）、什么是方法重载
前提：在同一类里面
方法名相同，形参列表不同的方法就是重载方法
影响形参列表不同因素：
1、参数的数据类型不同
2、参数的个数不同
3、参数的顺序不同（指的是参数数据类型的顺序）

重载方法的调用：根据传入实参去匹配，匹配上哪个就调用那个

注意：在同一个类里面相同的方法签名只能出现一次

可变参数

1、解决参数个数不确定的情况，将参数设置数组
但是调用这个方法的时候需要字节创建一个数组（很麻烦）
想要将创建数组这个工作交给JVM，使用可变参数来解决

2、语法：数据类型 ... 参数名，用在形参的位置，这就是可变参数

3、可变参数的注意事项

一个方法中最多只能有一个可变参数
可变参数要放在参数列表的最后
int ... arr,在调用方法的时候，参数个数可以任意（至少1个）
JVM会将你传入这个参数放到一个，jvm创建的数组中，数组名就是你指定可变参数的名字
在方法体里面使用可变参数（就是一个数组而已）

值传递和地址传递的区别

1、值传递：是相互不干扰的两个变量，在方法中怎样改变，原来那个变量的值不变

2、地址传递:是操作同一个数据，在方法中改变值，原来的值也会改

讲解Arrays这个类来使用api

Arrays是操作数组的一个类
有很多操作数组的方法
如果一个方法中所有的方法都是用static修饰，这个类就是工具类
类方法（静态方法的调用）：类名.方法名();

public class ApiDemo {
    public static void main(String[] args) {
        // 1、toString(int[] a) 将数组中所有的元素拼接成一个字符串。
        int[] arrs = {1, 30, 5, 17, 9, 12, 56, 100, 2};
        String s = Arrays.toString(arrs); // 快速查看数组中元素
//        System.out.println(s);

        // 2、fill(int[] a, int val) 将指定的int值分配给指定的int数组的每个元素。
//        Arrays.fill(arrs, 100);
//        System.out.println(Arrays.toString(arrs));

        // 3、copyOf(int[] original, int newLength) 扩容或缩容数组的
        // 扩容：将数组的长度变大，扩大后的值都是默认值
//        arrs = Arrays.copyOf(arrs,10); // 将arrs数组的长度扩容到10
//        String s = Arrays.toString(arrs); // 快速查看数组中元素
//        System.out.println(s);

        // 缩容:将数组的长度变小
//        arrs = Arrays.copyOf(arrs, 3); // 将 arrs的长度缩容的3
//        String s = Arrays.toString(arrs); // 快速查看数组中元素
//        System.out.println(s);

        // 4、copyOfRange(int[] original, int from, int to) 将指定数组的指定范围复制到新数组中。
//        int[] nums = Arrays.copyOfRange(arrs, 0, 3);// 将数组arrs,从下标为0开始，到下标为3（不含）
//        System.out.println(Arrays.toString(nums));

        // 5、sort(int[] a) 按照数字顺序排列指定的数组。 排所有的元素，只能升序
//        Arrays.sort(arrs);
//        System.out.println(Arrays.toString(arrs));

        // sort(int[] a, int fromIndex, int toIndex) 按升序排列数组的指定范围。
//        Arrays.sort(arrs,1,6);
//        System.out.println(Arrays.toString(arrs));

        // 6、binarySearch(int[] a, int key) 使用二分查找的方式来查询key在a数组第一次出现位置

        // 查找一个元素在数组第一次出现位置
        // 1)、顺序查找：遍历数组，一个一个比较
        // 2）、二分查找：前提：数组的元素必须要进行升序排序

        int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10};
        // 顺序查找：9，需要比较9次
        // 二分查找:找数组下标为：nums.length / 2元素
        // 第一次：用9和6比较，如果9大于6，在后半找
        // 第二次:9和8比较

//        int index = Arrays.binarySearch(nums, 9);// 在nums数组查找元素9第一次出现的位置
//        System.out.println(index);

        // binarySearch(int[] a, int fromIndex, int toIndex, int key) 使用二叉搜索算法搜索指定值的指定数组的范围。
        int index = Arrays.binarySearch(nums, 6, 10, 9);
        System.out.println(index);

//        1. 现有数组int[] arr = {1, 2, 3, 4, 5};
//            1.1 请将数组arr扩容到8个长度得到新数组，打印输出

//            1.2 请将数组arr缩容到2个长度得到新数组，打印输出
//
//        2. 将int数组arr中全部的元素批量初始化为666。考察api中的方法
//
//
//        3. 将int[] arr = {1, 2, 3, 4, 5, 6, 7}; 从下标1~4之间的所有元素复制到新数组
//        并且打印输出，注意包含下标4。考察api中的方法
    }
}