推荐是用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:堆 存储所有new出来的
    C:方法区(面向对象部分详细讲解)
    D:本地方法区(系统相关)
    E:寄存器(CPU使用)

    注意：
        a:局部变量 在方法定义中或者方法声明上定义的变量。
        b:栈内存和堆内存的区别
            栈：数据使用完毕，就消失。
            堆：每一个new出来的东西都有地址
                每一个变量都有默认值
                    byte,short,int,long 0
                    float,double 0.0
                    char '\u0000'
                    boolean false
                    引用类型 null
                数据使用完毕后，在垃圾回收器空闲的时候回收。
(6)数组内存图
    A:一个数组
    B:二个数组
    C:三个数组(两个栈变量指向同一个堆内存)
(7)数组的常见操作
    A:遍历
        方式1：
            public static void printArray(int[] arr) {
                for(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:最值
        最大值：
            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;
            }

        最小值：
            public static int getMin(int[] arr) {
                int min = arr[0];

                for(int x=1; x<arr.length; x++) {
                    if(arr[x] < min) {
                        min = arr[x];
                    }
                }

                return min;
            }
    C:逆序
        方式1：
            public static void reverse(int[] arr) {
                for(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：
            public static void reverse(int[] arr) {
                for(int start=0,end=arr.length-1; start<=end; start++,end--) {
                    int temp = arr[start];
                    arr[start] = arr[end];
                    arr[end] = temp;
                }
            }
    D:查表
            public static String getString(String[] strArray,int index) {
                return strArray[index];
            }
    E:基本查找
        方式1：
            public static int getIndex(int[] arr,int value) {
                for(int x=0; x<arr.length; x++) {
                    if(arr[x] == value) {
                        return x;
                    }
                }

                return -1;
            }

        方式2：
            public static int getIndex(int[] arr,int value) {
                int index = -1;

                for(int x=0; x<arr.length; x++) {
                    if(arr[x] == value) {
                        index = x;
                        break;
                    }
                }

                return index;
            }

1:二维数组(理解)
(1)元素是一维数组的数组。
(2)格式：
A:数据类型[][] 数组名 = new 数据类型[m][n];
B:数据类型[][] 数组名 = new 数据类型[m][];
C:数据类型[][] 数组名 = new 数据类型[][]{{…},{…},{…}};
D:数据类型[][] 数组名 = {{…},{…},{…}};
(3)案例(掌握):
A:二维数组的遍历
B:二维数组的求和
C:杨辉三角形

2:两个思考题(理解)
(1)Java中的参数传递问题
Java中只有值传递。

    基本类型：形式参数的改变不影响实际参数
    引用类型：形式参数的改变直接影响实际参数
(2)数据加密问题
    综合的小案例。

    举例：
        买电脑
        洗衣服
        做饭
        ...
        万事万物皆对象
(3)把大象装进冰箱(理解)
    A:面向过程实现
    B:面向对象实现

    注意：如何让我们的操作更符合面向对象思想呢?
    A:有哪些类
    B:每个类有哪些成员
    C:类与类的关系
(4)类与对象
    A:现实世界的事物
        属性  事物的基本描述
        行为  事物的功能
    B:Java语言中最基本的单位是类。所以，我们要用类来体现事物
    C:类
        成员变量    事物属性
        成员方法    事物行为
    D:类：是一组相关的属性和行为的集合。是一个抽象的概念。
      对象：是该类事物的具体存在，是一个具体的实例。(对象)

      举例：
        学生：类
        班长：对象
(5)类的定义及使用
    A:类的定义
        成员变量    定义格式和以前一样，就是位置不同，在类中，方法外。
        成员方法    定义格式和以前一样，就是去掉了static。
    B:使用类的内容
        a:创建对象? 格式
            类名 对象名 =  new 类名();
        b:如何使用成员变量和成员方法呢
            对象名.成员变量
            对象名.成员方法()
(6)案例：
    A:学生类的定义和使用
    B:手机类的定义和使用
(7)内存图
    A:一个对象的内存图
    B:二个对象的内存图
    C:三个对象的内存图
(8)Java程序的开发，设计和特征
    A:开发：就是不断的创建对象，通过对象调用功能
    B:设计：就是管理和维护对象间的关系
    C:特征
        a:封装
        b:继承
        c:多态

    思考题：构造方法中可不可以有return语句呢?
    可以。而是我们写成这个样子就OK了：return;
    其实，在任何的void类型的方法的最后你都可以写上：return;
(3)构造方法的注意事项
    A:如果我们没写构造方法，系统将提供一个默认的无参构造方法
    B:如果我们给出了构造方法，系统将不再提供默认构造方法
        如果这个时候，我们要使用无参构造方法，就必须自己给出。
        推荐：永远手动自己给出无参构造方法。
(4)给成员变量赋值的方式
    A:setXxx()
    B:带参构造方法
(5)标准案例
    class Student {
        private String name;
        private int age;

        public Student(){}

        public Student(String name,int age) {
            this.name = name;
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

    测试：
    class StudentDemo {
        public static void main(String[] args) {
            //方式1
            Student s1 = new Student();
            s1.setName("林青霞");
            s1.setAge(27);
            System.out.println(s1.getName()+"---"+s1.getAge());

            //方式2
            Student s2 = new Student("刘意",30);
            System.out.println(s2.getName()+"---"+s2.getAge());
        }
    }