方法 数组总结

1：方法（掌握）
    （1）方法：就是完成特定功能的代码块。
        注意：在很多语言里面有函数的定义，而在Java中，函数被称为方法。
    （2）格式：
        修饰符返回值类型方法名（参数类型参数名1，参数类型参数名2 ...）{
            方法体语句;
            return返回值;
        }

        修饰符：目前就用public static。后面再详细讲解其他修饰符
        返回值类型：就是功能结果的数据类型
        方法名：就是起了一个名字，方便我们调用该方法。
        参数类型：就是参数的数据类型
        参数名：变量就是
        参数分类照片：
            实参：参与实际运算的数据
            形参：方法上定义的，接收用于实际参数的变量
        方法行业释义体育语句：就是完成功能的代码块
        的回报：方法结束
        报道查看值：就是功能的结果，由return带给调用者。
    （3）两个明确：
        返回值类型：结果的数据类型
        参数列表：参数的个数及对应的数据类型
    （4）方法调用
        A：有明确返回值的方法
            a ：单独调用，没有意义
            b：输出调用，不是很好，因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了
            .c：赋值调用，推荐方案
        B：void类型修饰的方法
            a：单独调用
    （5）案例：
        A：求和方案
        B：获取两个数中的较大值
        C：比较两个数据是否相同
        d：获取三个数中的最大值
        E：输出米行Ñ列的星形
        F：输出ン乘法表
    （6）方法的注意事项
        答：方法不调用不执行
        B：方法之间是平级关系，不能嵌套定义
        C：方法定义的时候，参数是用，隔开的
        d：方法在调用的时候，不用在传递数据类型
        E：如果方法有明确的返回值类型，就必须有返回语句返回。
    （7）方法重载
        在同一个类中，方法名相同，参数列表不同。与返回值无关。
        
        参数列表不同：
            参数的个数不同。
            参数的对应的数据类型不同。
    （8）方法重载案例
        不同的类型的多个同名方法的比较
        
.2：数组（掌握）
    （1）数组：存储同一种数据类型的多个元素的容器。
    （2）特点：每一个元素都有编号，从0开始，最大编号是长度-1。
             编号的专业叫法：索引
    （3）定义格式
        A：数据类型[]数组名;
        B：数据类型数组名[];
        
        推荐是用A方式，B方法就忘了吧。
        但是要能看懂
    （4）数组的初始化
        A：动态初始化
            只给长度，系统给出默认值
            
            举例：int [ ] arr = new int [3];
        B：静态初始化给出
            值，系统决定长度
            
            举例：int [] arr = new int [] {1,2,3};
            简化版：int [] arr = {1,2,3};
    （5）Java的内存分配
        A：栈存储局部变量
        B：堆存储所有新出来的
        C：方法区（面向对象部分详细讲解）
        D：本地方法区（系统相关）
        E：寄存器（CPU使用）
        
        注意：
            a：局部变量在方法定义中或者方法声明上定义的变量
            .b：栈内存和堆内存的区别
                栈：数据使用完毕，就消失。
                堆：每一个新出来的东西都有地址
                    每一个变量都有默认值
                        byte，short，int，long 0
                        float，double 0.0
                        char'\ u0000'boolean
                        false
                        引用类型null
                    数据使用完毕后，在垃圾回收器空闲的时候回收。
    （6）数组内存图
        A：一个
        数组B：二个数组
        C：三个数组（两个栈变量指向同一个堆内存）
    （7）数组的常见操作
        答：遍历
            方式1：
                公共静态无效printArray（INT [] ARR）{
                    对于（INT X = 0; X < arr.length; x ++）{
                        System.out.println（arr [x]）;
                    }
                }
                
            方式2：
                public static void printArray（int [] arr）{
                    System.out.print（“[”）;
                    for（int x = 0; x <arr.length; x ++）{
                        if（x == arr.length-1）{
                            System.out.println（arr [x] +“]”）;
                        } else {
                            System.out.println（arr [x] +“，”）;
                        }
                    }
                }
        B：值最
            最大值：
                公共静态INT GetMax的（INT [] ARR）{
                    INT最大= ARR [0];
                    
                    for（int x = 1; x <arr.length; x ++）{
                        if（arr [x]> max）{
                            max = arr [x];
                        }
                    }
                    
                    返回最大值;
                }
                
            最小值：
                公共静态INT getMin（INT [] ARR）{
                    INT分钟= ARR [0];
                    
                    for（int x = 1; x <arr.length; x ++）{
                        if（arr [x] <min）{
                            min = arr [x];
                        }
                    }
                    
                    返回分钟;
                }
        C：逆序
            方式1：
                公共静态无效反向（INT [] ARR）{
                    对于（INT X = 0; X <arr.length / 2; X ++）{
                        int temp = arr [x];
                        arr [x] = arr [arr.length-1-x];
                        arr [arr.length-1-x] = temp;
                    }
                }
                
            方式2：
                公共静态无效反向（INT [] ARR）{
                    对于（INT开始= 0，结束= arr.length-1;启动<=结束;启动++，end--）{
                        INT临时= ARR [开始] ;
                        arr [start] = arr [end];
                        arr [end] = temp;
                    }
                }
        d：查表
                公共静态字符串的getString（字符串[] strArray，INT指数）{
                    返回strArray [指数];
                }
        E：查找基本
            方式1：
                公共静态INT getIndex（INT [] ARR，int值）{
                    对于（INT X = 0; X <arr.length; X ++）{
                        如果（ARR [X] ==值）{
                            返回X;
                        }
                    }
                    
                    返回-1;
                }
                
            方式2：
                公共静态INT getIndex（INT [] ARR，int值）{
                    INT指数= -1;
                
                    for（int x = 0; x <arr.length; x ++）{
                        if（arr [x] == value）{
                            index = x;
                            打破;
                        }
                    }
                    
                    返回索引;
                }