一、数组
1、数组是存储同一种数据类型多个元素的集合，也可以看做是一个容器
2、数据既可以存储基本数据类型的数据，也可以存储引用数据类型的数据

一维数据的语句定义格式：
    1、数据类型[] 数组名
        举例：int[] arr1
    2、数据类型 数组名[]
        举例：int arr2[]
    注意：针对于两种定义格式，推荐使用第一种格式，因为第一种的写法可读性更强
        第二种在早期确实有很多人使用，不过，现在使用第一种的人越来越多，将来java很有可能把第二种去掉
        
如果只是单纯的定义一个数组是没有任何意义的因为里面没有值，所以要在使用数据之前进行初始化，如果不初始化就不能使用
如何给一个数组进行初始化呢？
初始化：
    所谓的初始化，就是给数组中的元素进行分配内存空间，并为数组中的每个元素进行赋值
数组的初始化：
    1、动态初始化：
        初始化时只指定数组长度，由系统同（JVM）为数组分配初始值。
    2、静态初始化：
        初始化时指定每个数组元素的初始值，由系统（JVM）决定数组长度。
动态初始化：初始化只指定数组长度，由系统（JVM）为数组分配初始值。
    语句定义格式：数据类型[] 数组名 = new 数据类型[数组长度]；
    举例：int[] arr = new int[3]；
    解释：定义了一个可以存储三个int类型元素的数组
    
    左边：
        int：说明数组中存储的元素数据类型为int
        []：表示它是一个一维数组
        arr：表示这个数组的名字，符合表示符命名规则
        
    右边：
        new：今后但凡看到new，就说明给这个变量（对象）分配堆内存空间
        int：说明数组中存储的元素数据类型为int
        []：表示它是一个一维数组
        3：表示数组中可以存储3个元素，数组的长度为3
        
    今后我们在编写代码过程中，拿到地址值是没有任何意义的，我们更希望的是获取数组中存储的元素对应值
    java中数组提供一个获取数组中元素的方式，其中每一个元素都有一个编号，并且是从左往右开始编号，从0开始
    这样的编号，在大数据行业中有一个专业的叫法：索引
    通过这个索引来获取数组中的元素值，格式：数组名[索引]；
    获取第一个元素的值      int a = arr[0]；
                            System.out.println(a);
                            
                            
    我们学会了如何定义一个数组以及动态初始化，但是数组中的元素值是系统给的默认值
    通常情况下，我们更希望的是自己往数组中存放一些值，并获取使用？？？？
    
    
静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
语句定义格式：
    数据类型[] 数据名 = new 数据类型[]{元素值1，元素值2,...}；
    举例：int[] arr = new int[]{1,2,3,4,5};
    解释：定义一个存储int类型元素的数组，元素值为1,2,3,4,5总共5个元素，数组的长度为5
简化写法：
    数据类型[] 数组名 = {元素值1，元素值2，...}；
    举例：int[] arr2 = {11,22,33,44,55};
    
数组获取最值（获取数组中的最大值和最小值）
分析：
    1、定义一个数组，并对数组进行静态初始化
    2、从数组中任取一个数据与其他数据进行比较大小（一般情况下取第一个，默认它就是最大值）
    3、拿着这第一个元素与其余的元素做比较，如果找到了更大的元素，就把它取代掉 ，如果说比较的结果是比它小的话不管它继续向后比较
    4、直到比较到最后一个数，留下的最大值就是数组中的最大值。

二、二维数组
二维数组：其实就是元素为一维数组的数组

定义格式1：
    数据类型[][] 数组名 = new 数据类型[m][n];
    m：表示的是这个二维数组中有多少个元素，这里的元素就是一维数组
    n：表示每一个一维数组中有多少个元素
    
    举例：int[][] arr = new int[3][2]；
    解释 ：定义了一个二维数组，元素个数为3个一维数组，每一个一维数组的元素个数为2.
    
    注意：以下转换格式也算作定义二维数组（面试的时候可能会用到，看别人的代码）
    a：数据类型[] 数组名[] = new 数据类型[m][n]；
    b：数据类型 数组名[][] = new 数据类型[m][n]；
    
定义格式2：
    数据类型[][] 变量名 = new 数据类型[m][]；
    m表示这个二维数组有多少个一维数组
    这一次没有直接给出有一位数组的元素个数，可以动态的给出。
    
    举例：
        int[][] arr = new int[3][]；
        
定义格式3：手动赋值（类似于一维数组中的静态初始化）
    数据类型[][] 变量名 = new 数据类型[][]{{元素...},{元素...},{元素...}};
    简化版个税：
    数据类型[][] 变量名 = {{元素...},{元素...},{元素...}};
    
    举例：
        int[][]  arr = new int[][]{{1,2,3},{12,7},{11,22,33,44,55}};
        
    注意：
        不要和格式1、2混淆使用
        错误格式：
            int[][] arr = new int[3][]{{{1,2,3},{12,7},{11,22,33,44,55}};









一、参数
注意：
当基本数据类型作为实参传入方法的时候，传的是具体的值，方法中的变化，不会影响到方法外的变量值的变化。
当引用数据类型作为实参传入方法的时候，传的是地址值，方法中的变化，实际会影响到地址值对应的那个空间中的值变化。

二、
事物：
属性：事物相关信息的描述
行为：事物能够做什么
类：
成员变量：事物的属性
成员方法：事物的行为
定义一个类，其实就是在定义该类的成员变量和成员方法。
案例：我们尝试着来定义一个学生类

学生：
    属性：姓名、年龄、性别
    行为：学习、吃饭、睡觉

类：
    成员变量：name,age,gender
    成员方法：study(),eat().sleep()
    
 如何定义成员方法：
    修饰符 返回值类型 方法名(参数列表){
        方法体;
    }

注意：现在要求大家，不要将staic写上去，就用public














一个文件写两个类：
    一个是基础的类（要去创建对象的类，一个是测试类）
    有几个class，就会编译生成几个class文件
    public修饰的class类在一个java文件中只能存在一个，同时，如果存在了，java文件的名称要与修饰的class类名一致
    
在同一个包下面的class文件不能重名，即使它不作为java文件的名字。


成员变量：定义在类中方法外
局部变量：在方法定义上或者方法内部定义

成员变量和局部变量区别：
    1、在类中的定义位置不同
        成员变量：类中，但是在方法外
        局部变量：定义在方法内部
    2、在内存中的位置也不同
        成员变量：在堆内存中
        局部变量：在栈内存中
    3、生命周期不同
        成员变量：随着对象的创建而创建，随着对象的消失而消失
        局部变量：随着方法的调用而创建，随着方法的调用完毕而消失
    4、初始化值不同
        成员变量：有系统给的默认值
        局部变量：没有系统给它默认值，必须在定义的时候赋值，或者在方法内部使用之前进行赋值，然后才能使用，推荐定义的时候就赋值
        
注意事项：
1、成员变量与局部变量的名称可以是一样的嘛？
    可以是一样的，但是使用的时候，遵循就近原则。
    会先在局部范围内查找变量，如果局部范围内都没有，就去类方法外（成员位置）去找，如果成员位置上都没有，报错找不到
2、方法与方法之间里面的局部变量不可互相调用！！



形式参数的问题：
    基本参数类型作为形式参数的时候：形式参数的改变不会影响到实际参数
    引用数据类型作为形式参数的时候：形式参数的改变会直接影响到实际参数
    
定义一个学生类：
    成员变量：name，age
    成员方法：show（）方法
    
我们在使用对象给成员变量进行赋值中发现一个问题：
    通过对象给成员变量进行的赋值的时候，可以赋值一些与现实生活冲突的数据（非法数据）
    但是这样的数据是不合理的。
    我们应该在赋值之前，做一次数据的校验，也就是对数据进行一次判断。
    问题来了，我们应该在哪里定义判断呢？
    StudentDemo2类是一个测试类，一般情况下，测试类只能创建对象并使用对象，调用方法或者是访问成员变量。
    
    所以，我们的判断逻辑应该定义在Student2类中。
    因为，我们在定义成员变量的时候，不能加上数据判断，
    又因为数据判断的时候，加的是一些逻辑逻辑，不是一两句能够搞定的
    逻辑判断语句应该定义在方法中，所以，我们最后区添加判断的时候，应该在Student2类中提供一个方法来进行数据校验。
    
    虽然我们添加了判断条件来进数据校验，但是呢，我们偏偏不用这个方法来赋值，所以还是可以赋值一些非法的数据
    这样的话我们给出的方法就不起作用了，或者说意义不大。
    我们应该要求调用者必须使用我们给出的方法来进行数据的赋值，而不能通过直接访问成员变量来进行赋值
    怎么才强制要求调用使用方法进行赋值呢？
    java针对这种情况，提供了一个关键字给我们使用：private
    
    private:私有的。可以修饰成员变量和成员方法。
        注意：被private修饰的成员变量或者成员方法，只能在本类中访问，其他类中无法访问。
        
    其实这个案例说到现在，讲解的其实就是一个思想：封装
    封装：其实就是指隐藏对象的属性和相关实现细节，仅仅对外提供公共的访问方式。
    
    
匿名对象：简单来说其实就是没有名字的对象
    1、调用方法的时候，仅仅调用一次的时候
        注意，如果你想调用多次，就不适合使用匿名对象
        那么，为什么还要有匿名对象这个技术存在呢？
            因为匿名对象使用完后，由于没有栈中的引用指向他，那么它使用完毕后，就是一个堆内存中的垃圾空间
            可以被垃圾回收器回收
    2、匿名对象可以作为实际参数进行传递
    
封装与private的使用（标准类的写法 1.0）
    1、把成员变量用private修饰
    2、提供对应公共的getXxx()和setXxx()方法
    
private:
    是一个权限修饰符
    可以修饰成员变量也可以修饰成员方法
    被修饰的成员变量或者是成员方法只能在本类中进行方法

   要想使外界可以访问私有的成员，可以使用间接的方式来访问（java最后一节课的时候我们讲解反射，这个技术可以直接访问到私有的）