一、关键字

定义：被 Java 赋予特殊含义的单词。
特点：基本上都是英文小写。

1. 用于定义数据类型的关键字

    基本数据类型
        整数型（默认为 int）
            byte（8 位，1 字节，默认值是 0，最大存储数据量是 2^8-1，数据范围是 -2^7 ~ 2^7-1 之间）
            short（16 位，2 字节，默认值是 0，最大存储数据量是 2^16-1，数据范围是 -2^15 ~ 2^15-1 之间）
            int（32 位，4 字节，默认值是 0，最大存储数据量是 2^32-1，数据范围是 -2^31 ~ 2^31-1 之间）
            long（64 位，8 字节，默认值是 0L，最大存储数据量是 2^64-1，数据范围是 -2^63 ~ 2^63-1 之间）
        浮点型（默认为 double）
            float（32 位，4 字节，默认值是 0.0f，范围是 -3.40E38 ~ 3.40E38 之间）
            double（64 位，8 字节，默认值是 0.0d，范围是 -1.79E308 ~ 1.79E308 之间）
        字符型
            char（16 位，2 字节，Unicode 码，最小值是 \u0000（0），最大值是 \uffff（65535））
        布尔型
            boolean（1 位，默认值是 false）
    引用数据类型
        class（类）
        interface（接口）
        enum（枚举）
        数组
        注解
    void（用于方法（函数）上表示无返回值类型）
   

2. 用于定义数据类型值的关键字

    true（真）
    false（假）
    null（空）
   

3. 用于定义流程控制的关键字

    判断
        if
        else
        switch
        case
        default
    循环
        for
        while
        do
    继续循环
        continue
    结束循环或选择语句
        break
    返回
        return
   

4. 用于定义访问权限修饰符的关键字

    public（公有的）
    protected（受保护的）
    private（私有的）
   

5. 用于定义类、方法（函数）、变量修饰符的关键字

    abstract（抽象的）
    static（静态的）
    final（最终的）
    synchronized（同步的）
    enum（枚举）
   

6. 用于定义类与类之间关系的关键字

    extends（继承）
    implements（实现）
   

7. 用于定义建立实例、引用实例及判断实例的关键字

    new（建立实例）
    this（当前引用）
    super（父类引用）
    instanceof（判断对象类型）
   

8. 用于异常处理的关键字

    try（检查异常）
    catch（捕获异常）
    finally（最终执行）
    throw（抛出异常）
    throws（抛出异常）
   

9. 用于包的关键字

    package（创建包）
    import（导入包）
   

10. 用于其它修饰的关键字

    native（本地）
    strictfp（strict float point）（精确浮点）
    volatile（类型修饰符）
    transient（变量修饰符）
    assert（断言）
    

注：main 不是关键字，只是被虚拟机（JVM）所识别的一个名称标识。

二、标识符

• 定义：程序中自定义名称，由 26 个大小写英文字母、数字 0 ~ 9、符号 _$ 组成。
• 定义合法标识符的规则：

  1. 不允许数字开头。

  2. 不允许使用关键字。

      注：
          1. Java 中严格区分标识符的大小写。
          2. 为了提高可阅读性，起名字时，要有意义。
     

• 名称规范：

  1. 包名：多个单词组成时，所有字母都小写。

      例如：xxxyyyzzz
     

  2. 类/接口名：多单词组成时，所有单词的首字母大写。

      例如：XxxYyyZzz
     

  3. 变量/方法（函数）名：多单词组成时，第一个单词首字母小写，第二个单词开始，每个单词首字母大写。

      例如：xxxYyyZzz
     

  4. 常量名：所有字母都大写，多单词组成时，每个单词用_（下划线）连接。

      例如：XXX_YYY_ZZZ
     

三、常量

• 定义：Java 中固定不变的、表示不能改变的值。

• Java 中常量的分类：

    1. 整数常量：所有整数。
        十进制：0 ~ 9，满 10 进 1。
        八进制：0 ~ 7，满 8 进 1，用 0 开头来表示。
        十六进制：0 ~ 9、A ~ F，满 16 进 1，用 0x 开头来表示。
    2. 小数常量：所有小数。
    3. 布尔型常量：true、false。
    4. 字符常量：将一个数字/字母/符号用单引号（''）标识。
    5. 字符串常量：将一个或者多个字符用双引号（""）标识。
    6. null 常量：null。
  

• 进制的基本转换：

  • 十进制转换为二进制

      例如：9 的二进制算法
              9 / 2 = 4 —— 1（余数）
              4 / 2 = 2 —— 0（余数）
              2 / 2 = 1 —— 0（余数）
              1 除不尽（最后余数）
              结果要从下往上写，9 的二进制为：1001。
    

  • 二进制转换为十进制

      例如：1100 的十进制算法
              2^3 × 1 + 2^2 × 1 + 2^1 × 0 + 2^0 × 0 = 12
    

  • 十进制转二进制，除 2 取余数倒写；二进制转十进制，乘 2 的幂数。

  • 十进制、八进制、十六进制的互转，类似十进制与二进制的方法；亦可先讲十进制转换为二进制，再把二进制转换为八进制或十六进制（一个八进制位相当于三个二进制位，一个十六进制位相当于四个二进制位）。

  • 负数的二进制表现形式：将二进制对应的数取反，然后加 1 即可（注：负数的最高位都为 1）。

      例如：-6 的二进制
              6 的二进制为 0000 0000 0000 0000 0000 0000 0000 0110
              取反为 1111 1111 1111 1111 1111 1111 1111 1001
              加 1 后的最终结果为 1111 1111 1111 1111 1111 1111 1111 1010
    

四、变量

• 定义：内存中的一个存储空间，有自己的名称（变量名）和类型（数据类型）。
• 作用：用来存放同一类型的数据，并且可以重复使用。
• 格式：数据类型 变量名 = 初始值;
• 类型的自动提升：

  • 运算中，低类型与高类型进行数据计算时，会自动将表达式中的低类型提升为高类型。

      例如：
          byte b = 3;
          int c;
          c = b + 2;//b 会自动提示为 int 类型，再进行运算。
    

• 强制类型转换：

  • 当需要进行类型数据变换时，可以进行强制转换。

      例如：
          byte b = 3;
          b = b + 4;//报错
          b = (byte)b + 4;//强制类型转换，强制将 b + 4 的结果转换为 byte 类型，再赋值给 b
    

五、运算符

• 算术运算符

    *（乘）
                                    例如：3 * 4 = 12;
    /（除）
                                    例如：5 / 5 = 1;
    %（取模）
                                    例如：5 % 5 = 0;
                                    注：取模运算时，如果存在负数，运算结果取决于运算式左边有没有负数。
    -（减）
                                    例如：6 - 4 = 2;
    -（负号）
                                    例如：i = 4; -i; -4;
    +（加）
                                    例如：5 + 5 = 10;
    +（正号）
                                    例如：i = 3; +i; 3;
    +（字符串相加）
                                    例如："He" + "llo" = "Hello";
                                    注：字符串数据和任何数据使用 + 相连接，最终都会变成字符串。
    ++（自增）（前）
                                    例如：a = 2; b = ++a; a = 3; b = 3;
    ++（自增）（后）
                                    例如：a = 2; b = a++; a = 3; b = 2;
    --（自减）（前）
                                    例如：a = 2; b = --a; a = 1; b = 1;
    --（自减）（后）
                                    例如：a = 2; b = a--; a = 1; b = 2;
  

• 赋值运算符

    =（等于）
                                    例如：int i = 3;
    +=（加等于）
                                    例如：int a = 3; a += 5;//等同于 a = a + 5;
    -=（减等于）
                                    例如：int a = 3; a -= 5;//等同于 a = a - 5;
    *=（乘等于）
                                    例如：int a = 3; a *= 5;//等同于 a = a * 5;
    /=（除等于）
                                    例如：int a = 3; a /= 5;//等同于 a = a / 5;
    %=（模等于）
                                    例如：int a = 3; a %= 5;//等同于 a = a % 5;
  

• 比较运算符

    <（小于）
                                    例如：3 < 5; true;
    >（大于）
                                    例如：3 > 5; false;
    <=（小于等于）
                                    例如：3 <= 5; true;
    >=（大于等于）
                                    例如：3 >= 5; false;
    !=（不等于）
                                    例如：3 != 5; true;
    ==（等等于）
                                    例如：3 == 5; false;
    instanceof（检查是否为类的实例对象）
                                    例如："Hello" instanceof String; true;
    注：比较运算符的结果都是 boolean 型，要么是 true，要么是 false。
  

• 逻辑运算符

    概念：逻辑运算符是用于连接 boolean 类型的表达式
  
    !（非）
                                    例如：! true; false;
                                    注：结果为相反
    ^（异或）
                                    例如：true ^ false; true;
                                    注：两边相同，结果为 false; 两边不同，结果为 true。
    &（与）
                                    例如：true & false; false;
                                    注：两边有一个为 false，结果为 false; 两边都为 true，结果为 true。
    |（或）
                                    例如：true | false; true;
                                    注：两边有一个为 true，结果为 true; 两边都为 false，结果为 false。
    &&（双与）
                                    例如：true && false; false;
                                    注：如果左边为 true，右边才参与运算；如果左边为 false，右边不参与运算。
    ||（双或）
                                    例如：true || false; true;
                                    注：如果左边为 false，右边才参与运算；如果左边为 true，右边不参与运算。
  

• 位运算符

    ~（反码）
                                    注：二进制进行取反。
    ^（异或）
                                    注：相同的二进制，结果为 0；不同的二进制，结果为 1。
    &（与）
                                    注：有 0 时，结果为 0。
    |（或）
                                    注：有 1 时，结果为 1。
    <<（左移）
                                    注：被移除的高位丢弃，空缺位都补 0。
    >>（右移）
                                    注：被移除的最高位为 0，右移后，低位丢弃，空缺位补 0；被移除的最高位为 1，右移后，低位丢弃，空缺位补 1。
    >>>（无符号右移）
                                    注：被移除的最高位无论是 0 或者是 1，空缺位都补 0。
  

• 三元运算符

    格式：（条件表达式）? 表达式 1: 表达式 2;
        注：
            如果条件表达式结果为 true，执行表达式 1；
            如果条件表达式结果为 false，执行表达式 2。
        例如：
            int x = 3, y = 5, z;
            z = (x > y)? x : y;//x > y? 的结果为 false，执行表达式 2
            z = 5;//y 的值赋给 z
  

• 运算符的优先级如下：

  

六、转义字符

• 概念：通过 \ 来转变后面字母或者字符的含义。

    常用转义字符：
                \'：单引号
                \"：双引号
                \\：反斜杠
                \b：退格
                \n：换行
                \r：回车
                \t：制表符，相当于 tab 键
  

七、数组

• 概念：同一种数据类型的集合。也就是说，用来装数据类型的容器，被称为集合。

• 好处：可以自动给数组中的元素添加编号，编号从 0 开始，方便操作元素。

• 格式：

    元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
        例如：int[] arr = new int[3];
    元素类型[] 数组名 = new 元素类型[]{元素 1,元素 2,元素 3,…};
        例如：int[] arr = new int[]{1,2,3};
    元素类型[] 数组名 = {元素 1,元素 2,元素 3,…};（简化的静态初始化格式）
        例如：int[] arr = {1,2,3};
    注：new 是用来在堆内存中产生容器实体。
  

• 数组是引用数据类型，内存分配如下：

  

    注：
        1. System.out.println(arr);//输出的结果为一个哈希值，也称为地址值。
        2. 数组在堆内存中开辟空间后，都会有默认的初始值，各个数据类型对应各各自的初始值。如：int 默认 0。
        3. 堆内存开辟空间保存数据，桟内存保存对应的哈希值，通过哈希值指引到堆内存中的数据。
  

• 内存初步了解：

    1. 程序运行时，需要在内存中分配对应的空间。为了提高运算的效率，对内存空间进行了不同区域的划分，每一片区域都有特定的处理数据方式和内存管理方式。
    2. 桟内存：
        用于存储局部变量，数据使用完毕，占用空间会自动释放。
    3. 堆内存：
        1. 通过 new 建立的实例都存储在堆内存中。
        2. 每一个实体都有内存地址值。
        3. 实体中的变量都有默认初始值。
        4. 实体在不被使用的时候，在不确定的时间内会被垃圾回收器回收。
  

• 数组操作的常见问题：

    1. NullPointerException（空指针异常）
        例如：
                int[] arr = null;
                System.out.println(arr[0]);//NullPointerException
        注：数组的引用没有指向实体，却操作实体中的元素，就会报出 NullPointerException（空指针异常）。
    2. ArrayIndexOutOfBoundsException（数组脚标越界异常）
        例如：
                int[] arr = new int[3];
                System.out.println(arr[5]);//ArrayIndexOutOfBoundsException
        注：  访问了数组中不存在的脚标时，就会报出 ArrayIndexOutOfBoundsException（数组脚标越界异常）。
  

• 数组的常见操作：

  1. 排序：常见的简单排序方式有选择排序和冒泡排序。

     • 选择排序：

       

     • 冒泡排序：

       

  2. 查找：最常见的查找方式有折半查找（二分查找）。

     • 折半查找：

       

  3. 进制转换：十进制转换为二进制、八进制、十六进制等。

     

• 数组中的数组：多维数组。

  • 常见的二维数组

      格式：
              元素类型[][] 数组名 = new 元素类型[一维数组的个数][一维数组的元素个数或数组长度];
                  例如：int[][] arr = new int[2][3]; arr[0][0] = 58;
                  说明：这种格式表示定义了名称为 arr 的二维数组。二维数组中有 2 个一维数组，每个一维数组中有 3 个元素，一维数组的名称分别是 arr[0]，arr[1]，并且给第一个一维数组的 0 脚标元素赋值 58。
              元素类型[][] 数组名 = new 元素类型[一维数组的个数][];
                  例如：int[][] arr = new int[2][];
                  注：这种格式中的每一个一维数组的默认初始值都为 null。
              元素类型[][] 数组名 = {{元素 1,…},{元素 1,元素 2,…},{元素 1,元素 2,元素 3,…},…};（简化的静态初始化格式）
                  例如：int[][] arr = {{2,3}{3,5,8},{8,10,12,15}};
    

    • 二维数组的内存分配如下：

      

八、程序流程控制

• 程序流程控制也成为语句，主要有：判断结构、选择结构、循环结构。

  1. 判断结构（if）

      1. if(条件表达式){
              执行语句;
          }
      2. if(条件表达式){
              执行语句;
          }else{
              执行语句;
          }
      3. if(条件表达式){
              执行语句;
          }else if(条件表达式){
              执行语句;
          }
          …
          else{
              执行语句;
          }
      注：
          每一种格式都是单条语句；
          当第二种格式的执行语句都是有值出现的情况下，可以用三元运算符表示，简化 if else 的代码；
          无论条件表达式是什么样，条件表达式的结构不是 true 就是 false。
     

  2. 选择结构（switch）

      switch(条件表达式){
          case 取值 1:
                      执行语句;
                      break;
          case 取值 2:
                      执行语句;
                      break;
          case 取值 3:
                      执行语句;
                      break;
          …
          default:
                      执行语句;
                      break;
      }
      注：
          取值的类型有：byte、short、int、char、enum（JDK5 以后支持）、String（JDK7 以后支持）；
          case 与 default 没有书写顺序要求，先执行 case，如果没有匹配的 case 再执行 default；
          如果匹配的 case 或者 default 没有对应的 break，程序会继续向下执行，运行可执行的语句，直到结束。
          结束的两种情况：
                          1. 遇到 break，跳出 switch 并结束。
                          2. 执行到 switch 的结尾即是结束。
          switch 相对于 if 有效率更高的优势，因此在符合 case 取值类型的情况下，建议优先使用 switch。
     

  3. 循环结构（for、while、do while）

      for(初始化表达式;循环条件表达式;循环后的操作表达式){
          执行语句;
      }
      注：
          初始化表达式只执行一次；
          循环条件表达式结果为 true，进入循环体执行语句，然后再执行循环后的操作表达式；
          再次执行循环条件表达式，重复执行这个过程，直到循环条件表达式的结果为 false 为止，结束循环。
      while(循环条件表达式){
          执行语句;
      }
      注：
          先判断循环条件，结果为 true 才进入循环体执行语句。
      do{
          执行语句;
      }while(循环条件表达式);
      注：
          先进入循环体执行语句，再判断循环条件，结果为 true 才继续进入循环体执行语句；
          无论条件是否为 true，循环体的执行语句至少都会执行一次。
     

  4. 其它流程控制语句（break、continue）

      break（跳出）语句：选择结构和循环结构中使用。
      continue（继续）语句：循环结构中使用。
      注：
          如果脱离对应的结构语句，单独使用是没有意义的；
          continue 语句是结束本次循环，继续进入下一次循环；
          break 和 continue 语句的后面不允许有其它语句，因为不会向下执行。
     

九、函数（方法）

• 概念：定义在类中，具有特定功能的一段独立小程序，称为函数，也称为方法。

• 格式：

    修饰符 返回值类型 函数名(参数类型 形式参数 1,参数类型 形式参数 2,参数类型 形式参数 3,…){
        执行语句;
        return 返回值;
    }
    说明：
            返回值类型：函数运行后结果的数据类型。
            参数类型：形式参数的数据类型。
            形式参数：变量，用于储存调用函数时传递给函数的实际参数。
            实际参数：传递给形式参数的具体数值。
            return：结束函数。
            返回值：返回给调用函数的调用者。
    特点：
            函数只有被调用才会执行；
            函数的出现提高了代码的复用性；
            定义函数在于可以将功能代码进行封装，以便于对该功能进行复用。
    注：
        函数只能调用函数，不允许在函数内部定义函数；
        对于函数不需要返回值的情况，返回值类型可以使用关键字 void 表示，这样的函数中最后一行的 return 可以省略不写。
  

• 重载：在同一个类中，允许存在多个的同名函数，只要参数列表中的个数或者参数类型不同即可。

  • 优势：便于阅读、优化程序。

  • 使用场景：当定义的功能相同，但参与运算的未知内容不同时，此时可以定义一个函数名称以表示功能，以方便阅读，通过不同的参数列表来区分多个同名的函数。

      例如：
          //返回两个整数的和
          public int add(int x,int y){
              return x+y;
          }
          //返回三个整数的和
          public int add(int x,int y,int z){
              return x+y+z;
          }
          //返回两个小数的和
          public double add(double x,double y){
              return x+y;
          }