学习笔记：Java的基本语法

**

一、标识符和关键字

**

1.标识符

1.1 什么是标识符？

• Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
• 简而言之，凡是可以自己起名字的地方就叫标识符。

1.2 标识符的命名规则

• 标识符可以由数字、字母、下划线“_”、和美元符号“$”组成，其中数字不能打头。
• 标识符不能是Java的关键字和保留字，但可以包含关键字和保留字。
• 标识符不能包含空格。
• 标识符只能包含“$”，不能包含@、#等其他特殊字符。

2.关键字

2.1 什么是关键字？

• Java语言中一些具有特殊用途的单词被称为关键字（keyword）。
• 当定义标识符时，不要让标识符和关键字相同，否则将迎引起错误。

//试图定义一个名为byte的变量，但是byte时关键字，所以将发生错误。
int byte;

• Java中所有关键字都是小写。
• Java一共包含50个关键字如表1.1所示。
  
  **

二、数据类型

• Java是强类型语言，强类型包含两方面含义：
  （1）所有的变量必须先声明，后使用。
  声明的变量的语法很简单，只要指定变量的类型和变量名即可，如下所示：

//type varName[ = 初始值];
int age = 18;

（2）指定类型的变量只能接受类型与之匹配的值。
这意味着每个变量和每个表达式都有一个在编译时就确定的类型。类型限制了一个变量能被赋的值，限制了一个表达式可以产生的值，限制了在这些的值上可以进行的操作，并确定了这些操作的含义。

1.基本数据类型

• Java的基本数据类型分为两大类：boolean类型和数值类型。

1.1 整型

• 通常所说的整型是指如下四种类型：
  （1）byte：一个byte类型整数在内存里占8位，表数范围是：-128（-2^7） ~ 127（2^7 - 1）
  （2）short：一个sort类型整数在内存里占16位，表数范围是：-32768(-2^15) ~ 32767(2^15-1)
  （3）int：一个int类型整数在内存里占32位，表数范围是：-2147483648(-2^31) ~ 2147483647(2^31-1)
  （4）long：一个long类型整数在内存里占64位，表数范围是：-2^63 ~ 2^63-1

• int是最常用的整数类型，因此在通常情况下，直接给出一个整数值就默认是int类型。除此之外，有以下两种情况必须指出。
  （1）如果直接将一个较小的整数值（在short或byte类型的表数范围内）赋给一个byte或short变量，系统会自动把这个整数值当成byte或short类型来处理。
  （2）如果使用一个巨大的整数值（超过int类的表数范围）时，Java不会自动把这个整数值当成long类来处理。如果希望系统把一个整数值当成long类型来处理，应在这个整数后面添加l或L作为后缀。通常推荐使用L，因为l容易与数字1搞混。

1.2 浮点型

• Java的浮点类型有两种：float 和 double。Java的浮点类型有固定的表数范围和字段长度与机器无关。
  （1）float类型代表单精度浮点数。一个float类型数值占4字节，32位。
  （2）double类型代表双精度浮点数。一个double类型数值占8字节，64位。
• Java语言的浮点数有两种表示形式。
  （1）十进制形式：此形式就是简单的浮点数，如5.13、3.14、314.0。但是该浮点数必须包含一个小数点，否则会被当做int类型来处理。
  （2）科学计数法形式：例如3.14e2（即3.14x10^2）。只有浮点类型的值可以使用科学计数法表示。

1.3字符型

• 字符型通常用来表示单个字符，字符值必须使用单引号（’）括起来。

• 字符型值有如下三种表示形式。
  （1）直接通过单个字符来指定字符型值。如’A’、‘0’、‘6’。
  （2）通过转义字符表示特殊字符型值，例如’\n’、’\t’等。
  （3）直接使用Unicode值来表示字符型值，格式是’\uXXXX’，其中XXXX代表一个十六进制的整数。

• Java语言中常用的转义字符如表2.1所示。
  
  1.4 布尔型

• 布尔型只有一个boolean类型，用于表示逻辑上的“真”或“假”。在Java语言中，boolean类型的数值只能是true或false，不能用0或非0来表示。其他基本数据类型也不能转换为boolean类型。

• boolean类型的值或变量主要用来做旗标来进行流程控制，Java语言中使用boolean类型的变量或值控制的流程主要有如下几种。
  （1）if条件控制语句
  （2）while循环控制语句
  （3）do while循环控制语句
  （4）for循环控制语句
  除此之外还可在三目运算符中使用。

1.5 基本类型的类型转换

在Java程序中，不同基本类型的值经常需要进行相互转换。Java提供的7种数值类型之间可以相互转换，有2种类型转换方式：自动类型转换和强制类型转换。

1.5.1 自动类型转换

Java所有的数值型变量可以相互转换，**如果系统支持把某种基本类型的值直接赋给另一种基本类型的变量，则这种方式被称为自动类型转换。**当把一个表数范围小的数值或变量直接赋给一个另一个表数范围大的变量时，系统将可以进行自动类型转换，否则就需要强制转换。自动类型转换图如下。

程序举例。

public class TypeConversion {
    public static void main(String[] args) {
        //定义一个int类型的整数变量
        int a = 8;
        //int类型可以自动转换为float类型
        float b = a;
        //下面将输出8.0
        System.out.println(b);
        //定义一个byte类型的整数变量
        byte c = 6;
        //下一行的代码会发生错误，因为byte类型不能自动转换为char类型
        //char d = c;
        //byte类型可以自动转换为double类型
        double e = c;
        //下面将输出6.0
        System.out.println(e);
    }
}

不仅如此，当把任何基本类型的值和字符串值进行连接运算时，基本类型的值将自动类型转换为字符串类型。可以把基本类型的值和一个空字符串进行连接。

public class TypeConversionString {
    public static void main(String[] args) {
        //下面的代码是错误的，因为5是一个整数，不能直接赋给一个字符串
        //String str1 = 5;
        //一个基本类型的值和字符串进行连接运算时，基本类型的值
        //自动转换为字符串
        String str2 = 6 + "";
        //下面将输出6
        System.out.println(str2);
        //下面语句输出9Hello！
        System.out.println(4 + 5 + "Hello!");
        //下面语句输出Hello！45，因为Hello！+ 3会把3当成字符串处理
        //而后再把4当成字符串处理
        System.out.println("Hello!" + 3 + 4);
    }
}

1.5.2 强制类型转换

若想把上图的中右边的类型转换为左边的类型，则必须进行强制类型转换。
强制类型转换的语法格式为：(targetType)value，强制类型转换的运算符为圆括号“（）”。

public class NarrowConversion {
    public static void main(String[] args) {
        int i = 233;
        //强制把一个int类型的值转换为byte
        byte j = (byte) i;
        //32位的int类型的值转换为8位的byte类型的值需要截断前面的24位
        //只保留后边的8位，然后通过换算得到-23
        //故下面将输出-23
        System.out.println(j);
        double k = 3.14;
        //强制把一个double类型的值转换为int类型
        int g = (int) k;
        //将一个浮点数强制转换为整数时，将直接截断浮点数的小数部分
        //因此，下面将输出3
        System.out.println(g);
    }
}

1.5.3 表达式类型的自动提升

当一个算术表达式中包含多个基本类型的值，整个算术表达式的数据类型将发生自动提升。Java定义了如下的自动提升规则。

• 所有的byte类型、short类型和char类型将被提升到char类型
• 整个算术表达式的数据类型自动提升到与表达式中最高等级操作数相同的类型

public class TypePromote {
    public static void main(String[] args) {
        //定义一个short类型变量
        short a = 3;
        //表达式中的变量a将自动提升到int类型，则右边的表达式的类型为int
        //将一个int类型的值赋给shoer类型变量将发生错误
        //a = a - 1;

        byte b = 10;
        char c = 'a';
        int d = 33;
        double e = 3.14;
        //右边表达式中最高等级操作数为e（double类型）
        //则右边表达式的类型为double类型，故赋给一double类型变量
        double number = b + c + d + e;
        //将输出143.14
        System.out.println(number);

        int f = 3;
        //右边表达式中两个操作数都是int类型，故右边表达式的类型为int
        //虽然10/3不能除尽，但依然可以得到一个int类型整数
        int intnumber = 10 / f;
        //将输出3
        System.out.println(f);

        //下面将先进行“"Hello!" + 'a'”运算，把'a'转换成字符串
        //拼接成字符串Hello!a
        //接着进行“"Hello!a" + 7”运算，这也是一个字符串连接运算
        //将得到Hello!a7
        //将输出字符串Hello!a7
        System.out.println("Hello!" + 'a' + 7);
        //下面将先进行“'a' + 7”运算，其中'a'自动转换为int类型
        //变成a对应的ASCII值：97
        //两者相加为104，然后进行“104 + "Hello!"”运算
        //这是一个字符串连接运算，将得到104Hello!
        //故将输出字符串104Hello!
        System.out.println('a' + 7 + "Hello!");
    }
}

2.引用数据类型

引用数据类型包含类、接口、数组，这些此处不细说，后边详细说明。

三、运算符

运算符是一种特殊的运算符号，用以表示数据的运算、赋值和比较等。Java语言使用运算符将一个或多个操作连缀成执行性语句，用以实现特定功能。
Java语言中的运算符可分为如下几种。

• 算术运算符
• 赋值运算符
• 比较运算符
• 逻辑运算符
• 位运算符
• 类型相关运算符

3.1 算术运算符

Java支持所有的基本算术运算符，这些算术运算符用于执行基本的数学运算：加、减、乘、除和求余等。

• +：加法运算符。例如如下代码：

   double a = 4.2;
   double b = 3.1;
   double number = a + b;
   //number的值为7.3
   System.out.println(number);

除此之外，+还可以作为字符串的连接运算符。

• -：减法运算符。例如如下代码：

   double a = 4.2;
   double b = 3.1;
   double number = a - b;
   //number的值为1.1
   System.out.println(number);

• *：乘法运算符。例如如下代码：

   double a = 4.2;
   double b = 3.1;
   double number = a * b;
   //number的值为13.02
   System.out.println(number);

• /：除法运算符。除法运算有些特殊，若除法运算的两个操作数为整数，则计算结果也为整数，若不能取整，则会将自然除法的结果截断为整数，例如10/3的结果为3。若除法运算的两个操作数为整数，则除数不可为0，否则将引发错误。
  但若除法运算中的一个或两个操作数为浮点数，则计算结果也为浮点数，这个结果就是自然除法的结果。此时允许除数是0或者0.0，得到的结果是正无穷大或者负无穷大。例如如下代码：

        double a = 4.2;
        double b = 3.1;
        double div = a / b;
        //div的值为1.3548387096774195
        System.out.println(div);
        //输出正无穷大：Infinity
        System.out.println(5 / 0.0);
        //输出负无穷大：-Infinity
        System.out.println(-5 / 0.0);

• %：求余运算符。求余运算符的结果不一定总是整数，他的计算结果是使用第一个操作数除以第二个操作数，得到第一个整除的结果后剩下的值就是余数。由于求余运算也要进行除法运算，因此如果求余运算的两个操作数都是整数类型，则求余运算的第二个操作数不能是0，否则将引发除以零异常。
  如果求余运算的一个或两个操作数是浮点数，则允许第二个操作数是0或者0.0，只是求余运算的结果为非数：NaN。0或0.0对零以外的任何数求余将得到0或0.0.例如如下代码：

        double a = 4.2;
        double b = 3.1;
        double mod = a % b;
        //mod的值为2.1
        System.out.println(mod);
        //输出非数：NaN
        System.out.println(+ 5 % 0.0);
        //输出非数：NaN
        System.out.println(+ -5 % 0.0);
        //输出0.0
        System.out.println(+ 0 % 5.0);
        //输出非数：NaN
        System.out.println(+ 0 % 0.0);

• ++：自加。该运算符有两个要点：（1）自加是单目运算符，只能操作一个数；（2）自加运算符只能操作单个数值型（整型、浮点型都行）的变量，不能操作常量或表达式。
  运算符既可以出现在操作数的左边，也可以出现在操作数的右边。如果把++放在左边，则先把操作数加1，然后才把操作数放入表达式运算；如果把++放在右边，则先把操作数放入表达式中运算，然后才把操作数加1。例如如下代码：

        int a = 5;
        //让a先执行算术运算，然后自加
        int b = a++ + 6;
        //输出的a的值为6，b的值为11
        System.out.println(a + "\n" + b);

执行完后，a的值为6，而b的值为11。当++在操作数右边时，先执行a + 6的运算（此时a的值为5），然后对a加1.对比下面代码：

        int a = 5;
        //让a先执行算术运算，然后自加
        int b = ++a + 6;
        //输出的a的值为6，b的值为12
        System.out.println(a + "\n" + b);

执行的结果是a的值为6，b的值为12.当++在操作数左边时，先对a加1，然后执行a + 6的运算（此时a的值为6），因此b为12。

• –：自减。也是单目运算符，用法与++基本相似，只是将操作数的值减1。
  自加和自减只能用于操作变量，不能用于操作数值直接量、常量或表达式。例如5++、4–都是错误的。

3.2 赋值运算符

赋值运算符用于为变量指定变量值，Java使用=作为赋值运算符。通常，使用赋值运算符将于1个直接量值赋给变量。除此之外，也可使用赋值运算符将一个变量的值赋给另一个变量。
赋值表达式是有值的，赋值表达式的值就是右边被赋的值。因此赋值运算符支持连续赋值，通过使用多个赋值运算符，可以一次为多个变量赋值。

      int a;
      int b;
      int c;
      //通过为a、b、c赋值，三个变量都是7
      a = b = c;
      //输出三个变量的值
      System.out.println(a + "\n" + b + "\n" + c);

3.3 位运算符

Java支持的位运算符有如下7个。

1.&：按位与。当两位同时为1时才返回1。
2.|：按位或。只要有一位为1即可返回1。
3.~：按位非。单目运算符，将操作数的每个位（包括符号位）全部取反。
4.^：按位异或。当两位相同时返回0，，不同时返回1.
5.<<：左移运算符。
6.>>：右移运算符。
7.>>>：无符号右移运算符。
一般来说，位运算符只能操作整数类型的变量或值。位运算符的运算法则如下表。

3.4 扩展后的赋值运算符

赋值运算符可与算术运算符、位移运算符结合，扩展成功能更加强大的运算符。扩展后的赋值运算符如下。

1.+=：对于x += y，即对应于x = x + y。
2.-=：对于x -= y，即对应于x = x - y。
3.*=：对于x *= y，即对应于x = x * y。
4./=：对于x /= y，即对应于x = x / y。
5.%=：对于x %= y，即对应于x = x % y。
6.&=：对于x &= y，即对应于x = x & y。
7.|=：对于x |= y，即对应于x = x | y。
8 ^=：对于x ^= y，即对应于x = x ^ y。
9.<<=：对于x <<= y，即对应于x = x << y。
10.>>=：对于x >>= y，即对应于x = x >> y。
11.>>>=：对于x >>>= y，即对应于x = x >>> y。

3.5 比较运算符

比较运算符用于判断两个变量或常量的大小，比较运算的结果是一个布尔值（true或false）。Java支持的比较运算符如下。

注意：（1） > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型。
（2）== 、 != 两边的操作数既可以是数值类型，也可以是引用类型。

3.6 逻辑运算符

逻辑运算符用于操作两个布尔型的变量或常量。逻辑运算符主要有如下6个。

3.7 三目运算符

三目运算符只有一个“ ? : ”，三目运算符的语法格式如下：
(expression) ? if-true-statement : if-false-statement;
三目运算符的规则是：先对逻辑表达式expression求值，如果逻辑表达式返回true，则返回第二个操作数的值，如果逻辑表达式返回false，则返回第三个操作数的值。看如下代码。

      String str = 5 > 3 ? "5大于3" : "5小于3";
      //输出"5大于3"
      System.out.println(str);

大部分时候，三目运算符都是作为if else的精简写法。因此，如果将上面的代码换成if else的写法，则代码如下（效果同上）。

        String str2 = null;
        if (5 > 3) {
            str2 = "5大于3";
        }else {
            str2 = "5小于3";
        }

这两种代码写法的效果是完全相同的。三目运算符和if else写法的区别在于：if后的代码块可以有多个语句，但三目运算符是不支持多个语句的。
三目运算符可以嵌套，嵌套后的三目运算符，嵌套后的三目运算符可以处理更复杂的情况，如下所示（效果同上）。

        int a =16;
        int b =18;
        //三目运算符支持嵌套
        System.out.println(a > b ? "a大于b" : (a < b ? "a小于b" : "a等于b"));

3.8 运算符的优先级
运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。下表列吃了所有运算符的优先级顺序，上一行中的运算符总是优先于下一行的。