1：函数
         (1)函数就是定义在类中的具有特定功能的一段独立小程序。函数也称为方法。
         (2)函数的格式
                修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，…) {
                        执行语句;
                        return 返回值;
                }
                public static int add(int a,int b)//a = 3,b =5
                A：修饰符 后面会重点讲。public static
                B：返回值类型 这个特定的功能完成后，需要返回一个结果。这个地方就是返回结果的类型。
                C：函数名 为了方便使用这个函数，给它起个名字。这个名字要符合标识符命名规则。
                D：参数类型 形式参数的数据类型
                        **：形式参数 自定义的接收方
                        **：实际参数 发出方add(3,5)
                E：执行语句 那么这个语句是由多条语句组成。
                F：return 这个功能执行完以后，需要有一个返回值，那么这个值有关键字return带回。
        (3)函数的特点
                A：一般函数只有被调用后，才执行。
                B：void 表示没有返回。在这个函数的结尾可以不写return。
                        **其实jvm会自动的结尾处加上return;
        (4)如果定义自己的函数 两个明确
                A：明确该功能的结果 其实就是该功能的返回类型。
                B：明确该功能的参数 其实就是明确该功能中是否需要未知内容(形式参数)参与运算。
                                    明确未知内容的类型和个数。
        (5)函数的重载
                A：函数名相同，参数列表不同。       
                        **参数类型不同。int add(int i)void add(double d)
                        **参数个数不同。add(int a,int b);add(int a,int b,int c)
                        **参数顺序不同  print(String name, int age)        //参数顺序不同的重载是可以存在的,但是没有什么实际意义
                                                        print(int age,String name)
                B：特点：与返回值类型无关，只看参数列表。
                C：好处：便于阅读，优化程序设计。

2：数组
        (1)同一种类型数据的集合。其实数组就是一个容器。int[] arr = new int[5];
                A：只要是容器，就得重点掌握。
        (2)数组的好处
                int[] arr = new int[5];
                arr[3] = 10;
                A：可以自动给数组中的元素从0开始编号，方便操作这些元素。
        (3)数组的定义格式
                A：当不明确数组中的元素时
                        **举例 int[] arr = new int[3];//动态初始化
                        '\u0000'
                        arr[0] = 3;
                B：当明确数组中的元素时
                        **举例 int[] arr = new int[]{1,2,3,4,5};//静态初始化
                                   int[] arr = {1,2,3,4,5};
                               
        (4)什么时候使用数组？
                A：当要操作的同种数据类型的数据是多个的时候，你就得想着先把这些数据用数组进行存储。
        (5)内存图
                A：栈
                        **存储的是局部变量(在函数中定义的变量)。
                        **变量被使用完后，立即自动释放。
                B：堆
                        **存储的是实体(数组和对象)。
                        **实体：new出来的东西，可以存放很多数据的东西。
                                ***class定义一个类。
                        **堆内存数据的特点
                                ***每个实体都有内存地址
                                ***堆内存中的变量都有默认初始化值
                                        ****int --> 0
                                        ****double --> 0.0
                                        ****boolean --> false
                                        ****char --> '\u0000' 空字符，unicode编码。
                                ***当实体不在被使用的时候，会在jvm空闲的时候，
                                   通过java垃圾回收机制使其自动释放。
                C：方法区 后面讲。
                D：本地方法区 调用是Windows系统底层资源，我们不用考虑。
                E：寄存器 和CPU相关。我们不用考虑。
        (6)操作数组最常见的问题
                A：当你访问到数组中的最后一个元素时，还想继续访问，这个时候，会发生角标越界异常。
                        **ArrayIndexOutOfBoundsException
                        **举例 int[] arr = new int[3];
                               System.out.println(arr[3]);
                B：当数组不在指向某个实体时，你还继续访问，就会发生空指针异常。
                        **NullPointerException
                        **举例 int[] arr = new int[3];
                               arr = null;
                               System.out.println(arr[1]);
        (7)常见的数组的操作
                记住：对数组的操作，一定要从角标入手。
                A：遍历操作
                        **数组的属性：length 数组的长度。
                        **格式：数组名.length
                for (int x=0;x < arr.length ;x++ )
                        System.out.println("arr["+x+"]="+ arr[x]);
               
                B：获取最值
                        **获取最大值
                        public static void main(String[] args) {
                                int[] arr = {3,2,1,4,5,6};
                                //int x = getMax(arr);
                                //System.out.println(x);
                        }
                        public static int getMax(int[] arr){
                                int max = arr[0];
                               
                                //i从1开始，因为第一个数不用跟自己比
                                for(int x=1; x<arr.length; x++) {
                                        if(arr[x]>max) {
                                                max = arr[x];
                                        }
                                }

                                return max;
                        }

                        **获取最小值
                        public static int getMin(int[] arr) {
                                int min = arr[0];
                               
                                //i从1开始，因为第一个数不用跟自己比
                                for(int i=1; i<arr.length; i++) {
                                        if(arr[i]<min){
                                                min = arr[i];
                                        }
                                }

                                return min;
                        }
                C：排序(选择和冒泡都还没有讲,大家可以先看一下)
                int[] arr = {66,55,44,33,22,11};
                        **选择排序
                        原理：如果拿0角标上的元素依次和后面的元素进行比较，
                              第一次内循环结束后，最小值出现在了0角标位置。
                        arr[0]与arr[1-5]比了五次
                        arr[1]与arr[2-5]比了四次
                        arr[2]与arr[3-5]比了三次
                        arr[3]与arr[4-5]比了二次
                        arr[4]与arr[5]比了一次
                        你就想想我们是如何打星星
                        *****
                        ****
                        ***
                        **
                        *
                        arr[x]与arr[y]比较
                        数组长度是6
                        for (int x = 0;x < arr.length - 1;x++){
                                for (int y = x + 1;y < arr.length;y++){
                                        if (arr[x] > arr[y]){
                                                int temp = arr[x];
                                                arr[x] = arr[y];
                                                arr[y] = temp;
                                        }
                                }
                        }
                        int[] arr = {66,55,44,33,22,11};
                        **冒泡排序
                        原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。
                        第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4],arr[4]与arr[5],比了五次
                        第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比了四次
                        第三次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比了三次
                        第四次:arr[0]与arr[1],arr[1]与arr[2]比了二次
                        第五次:arr[0]与arr[1]比了一次
                        for (int x = 0;x < arr.length - 1; x++){
                                //-1防止角标越界
                                //-x为了提高效率
                                for (int y = 0;y < arr.length - 1 - x;y++){//6
                                        if (arr[y] > arr[y+1]){
                                                int temp = arr[y];
                                                arr[y] = arr[y+1];
                                                arr[y+1] = temp;
                                        }
                                }
                        }
                D：传递参数
                        **调用的时候，传递是基本类型的值的时候，形参改变对实参没有任何影响。
                        **调用的时候，传递是引用类型的地址的时候，形参改变对实参有直接影响。
数组初始化过程
        <1> 主函数进栈,然后在main()中有一个数组的引用arr
        <2> 在堆内存中开辟空间，分配内存地址值
        <3> 在堆内存中建立数组对象，并进行默认初始化
        <4> 如果有显示初始化值的,对它进行显示初始化
        <5> 将内存地址赋给栈内存中的arr变量

日记分享么