/*
* 面向对象思想：
*                 面向对象是基于面向过程的编程思想。
*                 
*
*                 面向过程：强调的是每一个功能的步骤
*                 面向对象：强调的是对象，然后由对象去调用功能
*               
*面向对象的思想特点：
*                A:是一种更符合我们思考习惯的思想
*                B:可以将复杂的事情简单化
*                C:将我们从执行者变成了指挥者
*
*举例：
*                买电脑：
*                        面向过程：我要买电脑--我要明确买电脑的意义--上网查对应的参数信息--去中关村买电脑--讨价还价--买回电脑
*                        面向对象：我要买电脑--班长去给我买电脑--买回电脑
*                洗衣服：
*                        面向过程：把衣服脱下--找一个盆--放洗衣粉--加水--浸泡--揉--清洗--晾干
*                        面向对象：把衣服脱下--打开全自动洗衣机--放衣服--启动--晾干
*                        
*类：是一组相关属性和行为的集合，是Java语言最基本的单位。
*对象：类的具体体现
*                举例：  类  --> 学生
*                        对象 --> 班长
*
*类： 属性(基本属性)：由成员变量实现
*     行为(能够做什么)：由成员方法实现
*
*一个学生类：
*
*学生：
*                属性：姓名，年龄
*                行为：学习，吃饭
*
*学生类：
*                成员变量：姓名，年龄
*                成员方法：学习，吃饭
*
*成员变量：与一般变量的定义一样，
*                位置不同：类中，方法外
*                初始化值：不需要给初始化值
*
*成员方法：与一般方法的定义一样
*                去掉static关键字        
*
*static关键字：
*        A:概念：
*                一个修饰符，用于修饰成员变量和成员方法，不能修饰构造方法
*        B:特点：
*                a:静态成员属性被该类下的所有的对象共享
*                b:可以直接使用类名来调用
*                        eg：类名.静态修饰符修饰的变量名
*                            类名.静态修饰符修饰的方法名
*                c:静态所修饰的成员加载优先于对象，随着类(.class文件)的加载而存在于方法区中的静态区域，只加载一次
*
*static的注意事项：
*        静态方法：
*                可以调用静态的成员变量和成员方法
*                不可以调用非静态的成员变量和成员方法
*                *：静态方法只能调用静态的成员变量和成员方法
*
*        非静态方法：
*                可以调用静态的成员变量和成员方法
*                也可以调用非静态的成员变量和成员方法
*                *：非静态方法则都可以调用
*
*        *:在静态的方法中没有this对象，因为静态的方法随着类的加载而存在，优先于所有对象
*
*        static的优点：
*                A:对对象的共享数据提供单独空间的存储，节省空间，没必要每个对象都存储一份
*                B:可以直接被类名调用，不用在堆内存里创建对象
*
*        static的缺点：访问有局限性，静态只能访问静态
*               
*        static使用地点：用于工具类中，方便直接通过类名调用
*
*
*数组：存储多个同一种类型的数据的容器
*
*定义格式：
*                 A:数据类型[] 数组名;(int[] arr; 定义了一个int类型的数组，数组名是Arr)
*                 B:数据类型 数组名[];
*数组初始化：
*                         A：为数组开辟内存空间，并为数组中的每个元素富赋予初始值
*                         B:两种初始化方式：
*                                 a:动态初始化                只给出长度，由系统给初始值
*                                 b:静态初始化                给出初始值，由系统决定长度
*
*动态初始化：
*                         数据类型[] 数组名 = new 数据类型[数组长度];(数组长度的叫法：索引)
*
*静态初始化的格式：
*                         数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3...};
*                        
*                         简化格式：
*                         数据类型[] 数组名 = {元素1，元素2，元素3...}
*
*数组两个常见小问题：
*                         1：ArrayIndexOutOfBoundsException(数组索引越界异常)
*                                 原因：访问了不存在的索引
*                         2：NullPointerException(空指针异常)
*                                 原因：数组指针已经不再指向堆内存对应的地址了，则访问不了数组名对应的值
*
*length: 用于获取数组元素个数
*                 格式：数组名.length
*
*
*
*二维数组：其实就是元素为一位数组的数组。
*
*定义格式：
*                 A:数据类型[][] 数组名;
*                 B:数据类型 数组名[][];
*                 C:数据类型[] 数组名[];
*
*初始化：
*                 A:动态初始化
*                         数据类型[][] 数组名 = new 数据类型[m][n];
*                         m表示的是二维数组中一维数组的个数
*                         n表示的是一维数组中的元素个数
*                 B:静态初始化
*                         数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},...};
*                         简化格式:
*                         数据类型[][] 数组名 = {{元素...},{元素...},...};

                C:*动态初始化：
                        数据类型[][] 数组名 = new 数据类型[m][];//可以先定义二位数组中一维数组的个数
                        //再逐个定义每个一维数组的长度
                        数组名[0] = new 数据类型[a];
                        数组名[1] = new 数据类型;
                        ...
                        数组名[m-1] = new 数据类型[n];
                        //若a = 0，则数组名[0]是一个有地址值的无元素的引用
                                arr[0] = new int[0];//则打印arr[0]的地址
                          若不给数组名[x]定义一位数组的长度，则为null
                                不给arr[x]定义一位数组的长度//打印null        
*/

6666，加油！！！！！

加油！！！！！