Java学习之==>注释、数据类型、变量、运算符

一、注释

在Java中有3种标记注释的方式，最常用的方式是 // ，其注释的内容从 // 开始，到本行结束。但需要注意的是，我们不建议把注释写在代码的尾部（即尾注释），我们建议把注释写在代码的上一行，如下：

建议：

public class Test {
    public static void main(String[] args) {
        // 将Hello World输出到控制台
        System.out.println("Hello World!!");
    }
}

不建议：

public class Test {
    public static void main(String[] args) {       
        System.out.println("Hello World!!"); // 将Hello World输出到控制台
    }
}

如果我们的 Intellij IDEA上装了阿里巴巴的一款插件 Alibaba Java Coding Guidelines，它就会对这种尾注释进行说明，不建议使用这种注释，如下：

当需要长篇的注释时，既可以在每行的前面标记 //，也可以使用 /* 和 */ 将一段比较长的注释括起来，如下：

public class Test {
    public static void main(String[] args){
        /*
         第一个Java程序 5          */
        // println 打印后换行
        System.out.println("Hello World!!");
        // print 打印后不换行
        System.out.print("Hello World!!");
    }
}

第三种注释可以用来自动生成文档，这种注释以 /** 开始， 以 */ 结束，如下：

public class Test {
    public static void main(String[] args){
        /**
         * 第一个Java程序
         * @author xxx
         * date 2019-5-27
         */
        // println 打印后换行
        System.out.println("Hello World!!");
        // print 打印后不换行
        System.out.print("Hello World!!");
    }
}

二、数据类型

Java是一种强类型语言，这就意味着必须为每一个变量声明一种类型。在Java中，一共有8种基本数据类型，其中有4种整型、2种浮点型，另外还有一种用于表示Unicode字符编码的的字符类型 char 和一种用于表示真假值的 boolean 类型。

1、整型

整型用于表示没有小数部分的数值，它允许是负数。Java提供了4种整型，具体内容如下：

　　长整型数值有一个后缀L或 l 。十六进制的数值有一个前缀 0X 或 0x ，八进制的数值有一个前缀 0，例如，010 对应八进制种的 8，但很显然，八进制表示法比较容易混淆，所以建议最好不要用八进制常数。

　　从 Java7 开始，加上前缀 0B 或 0b 就表示二进制数。例如，0b1001就表示 9 。另外，同样是从 Java7 开始，还可以为数字加下划线，如用 1_000_000 表示一百万，这些下划线只是为了让人更容易读，Java 编译器会去除这些下划线。

2、浮点型

浮点型用于表示有小数部分的数值，同样也允许是负数。Java 提供了2种浮点型，具体内容如下：

　　double 类型的数值精度是 float 类型的两倍。绝大部分应用程序都使用 double 类型。在很多情况下，float 类型的精度很难满足需求。实际上，只有很少的情况适合使用 float 类型，例如，需要单精度数据的库，或者需要存储大量的数据。

　　float 类型的数值有一个后缀 F 或 f ，没有后缀的浮点数值默认为 double 类型。当然，也可以在浮点数值后面添加后缀 D 或 d 表示 数值是 double 类型。

所有的浮点数值计算都遵循 IEEE 754 规范。具体来说，下面是用于表示溢出和出错情况的三个特殊的浮点数值：

• 正无穷大
• 负无穷大
• NaN（不是一个数字）

例如，一个正整数除以 0 的结果为正无穷大，负整数除以 0 的结果则为负无穷大，计算 0/0 或者负数的平方根结果为 NaN。

3、char 类型

　　char 类型原本用来表示单个字符。如今，有些 Unicode 字符可以用一个 char 值描述，另外一些Unicode 字符则需要两个 char 值。

　　char 类型的字面量值要用单引号括起来。例如：'A' 是编码值为 65 所对应的字符常量，它与 "A" 不同，"A" 是包含一个字符 A 的字符串。char 类型的值可以表示为十六进制值，其范围从 \u0000 到 \Uffff，例如：\u03C0 表示希腊字母 π 。

　　除了转义序列 \u 之外，还有一些用于表示特殊字符的转义序列。所有这些转义序列都可以出现在加引号的字符字面量或字符串种，例如：'\u2111' 和 "Hello\n" 。转义序列 \u 还可以出现在加引号的字符常量或字符串之外，例如：public static void main(String\u005B\u005D)，者完全符合语法规则，\u005B 和 \u005D 是 [ 和 ] 的编码。特殊字符转义序列如下：

4、boolean类型

boolean（布尔）类型有两个值：true 和 false ，用来判断逻辑条件。整型值和布尔值之间不能进行相互转换。这点与Python当中不同，Python当中有一种用法叫做：非0即真，非空即真。

三、变量

在 Java 中，每个变量都有一个类型（type），在声明变量时，变量的类型位于变量名之前。下面列举一些声明变量的示例：

int vacationDays;

double salary;

long population;

boolean done;

可以看到，由于声明是一条完整的 Java 语句，所以必须以分号结束。变量名必须是一个以字母开头并由字母或数字构成的序列，但 '+' 和空格不能出现在变量名中。变量名中的所有字符都是有意义的，并且大小写敏感，变量名的长度基本上没有限制。另外，不能使用 Java 的保留字作为变量名。

1、变量初始化

声明一个变量后，必须用赋值语句对变量进行初始化。初始化需要将变量名放在等号（=）左侧，相应取值的Java表达式放在等号右侧，如下：

int vacationDays;
vacationDays = 10；

也可以将变量的声明和初始化放在同一行中，如下：

int vacationDays = 10；

2、常量

在 Java 中，使用关键字 final 指示常量，如下：

final double PRICE = 8.35;

关键字 final 表示这个变量只能被赋值一次，一旦被赋值后就不能再更改了，习惯上，常量名所有字母都大写。

在 Java 中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为类常量。可以使用关键字 static final 设置一个类常量，如下：

public static final double PRICE = 8.35;

需要注意的是：类常量通常定义在 main 方法的外部。因此，在同一个类的其他方法中也可以使用这个常量。如果这个常量被声明为 public ，那么其他类的方法也可以使用这个常量。

四、运算符

在 Java 中，使用算术运算符 +、-、*、/ 、% 表示加、减、乘、除、取模（求余）运算。当参与 / 运算的两个数都是整数时，表示整数除法，除不尽时取整数部分；当参与 / 运算的两个数其中有一个不是整数或都不是整数时，则表示浮点除法。

需要注意的是：整数被 0 除将会产生一个异常，而浮点数被 0 除将会得到无穷大或 NaN 的结果。

public void normal() {
  // + - * / %
  int num1 = 1024;
  int num2 = 1024;

  int result = num1 + num2;
  result = num1 - num2;
  result = num1 * num2;
  result = num1 / num2;
  int orderId = 342234234;
  int dbId = orderId % 8;
  System.out.println("dbId = " + dbId);
} 

1、数值类型的转换

经常需要将一种数值类型转换为另一种数值类型，下图给出了数值类型之间的合法转换：

在上图中有 6 个实心箭头，表示无信息丢失的转换；有 3 个虚箭头，表示可能有精度损失的转换。例如：123 456 789 是一个大整数，它所包含的位数比 float 类型所能表达的位数多，当将这个整型数值转换为 float 类型时，将会得到同样大小的结果，但却失去了一定的精度，如下：

public static void main(String[] args) {

    int n = 123456789;
    float f = n;
    System.out.println(f); // 1.23456792E8

}

当使用上面两个数值进行儿园操作时（例如：n + f，n 是整数，f 是浮点数），先要将两个数转换为同一种数据类型，然后再进行计算，如下：

• 如果两个数中有一个数是 double 类型，另一个操作数就换转换为 double 类型；
• 否则，如果其中一个数是 float 类型，另一个操作数将会转换为 float 类型；
• 否则，如果其中一个操作数是 long 类型，另一个操作数将会转换为 long 类型；
• 否则，两个数都将被转换为 int 类型；

2、强制类型转换

从上面我们可以看到，在必要的时候，int 类型的值将会自动转换为 double 类型。但另一方面，有时也需要将 double 类型转换成 int 类型。在Java 中，允许进行这种数值之间的转换，需要通过强制类型转换（cast）来实现这个操作，其语法如下：

public static void main(String[] args) {

    double d = 9.977;
    int n = (int) d;
    System.out.println(n); // 9

}

这样，变量 n 的值为 9，强制类型转换通过截断小数部分将浮点值转换为整型。如果相对浮点数进行四舍五入运算，以便得到最接近的整数，那就需要使用 Math.round 方法：

public static void main(String[] args) {

    double d = 9.977;
    int n = (int) Math.round(d);
    System.out.println(n); // 10

}

现在，变量 n 的值为 10。当调用 Math.round 的时候，仍然需要使用强制类型转换（int），其原因是 round 方法返回的结果是 long 类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将 long 类型转换成 int 类型。

3、结合赋值和运算符

可以在赋值种使用二元运算符，这是一种很方便的简写形式，例如：x += 4；等价于：x = x + 4；一般要把运算符放在 = 的左边，例如：*= 或 %= 。

如果运算符得到一个值，其类型与左侧操作数的类型不同，就会发生强制类型转换。例如：如果 x 是一个 int 类型的变量，则语句 x+=3.5；是合法的，将会把 x 设置为 (int)(x + 3.5)。

4、自增与自减运算符

我们都知道：加 1、减 1 是数值变量最常见的操作。在 Java 种也提供了自增、自减运算符，n++将变量 n 的当前值加 1，n-- 则将 n 的当前值减 1。

实际上自增与自减运算符有两种形式，一种是将（++）或（--）放在变量后面，还有一种是将（++）或（--）放在变量前面，虽然放在变量前面和放在变量后面都会使变量加 1 或减 1，但在实际运用过程种，二者是有区别的，如下：

public static void main(String[] args) {

    int m = 7;
    int n = 7;
    int a = 2 * ++m; // a = 16，m = 8
    int b = 2 * n++; // b = 14，n = 8
}

从上可以看出，前缀形式会先完成加 1，而后缀形式会使用变量原来的值。所以，建议不要再表达式种使用 ++ 或 --，因为这样的代码很容易让人困惑，而且会带来意想不到的bug。

5、关系运算符和逻辑运算符

关系运算符包括：==（相等）、!=（不相等）、>（大于）、<（小于）、>=（大于等于）、<=（大于等于）；

逻辑运算符包括：||（或）、&&（与）、！（非）；

其中，||（或）和 &&（与）运算符是按照 “短路” 的方式来求值的，如下：

如上图，表达式：flag1 || flag2 ，当 flag1 为 true 时，无论 flag2 为 true 或者是 false ，整个表达式都为 true，这时，如果 flag2是一个表达式的话，就不必计算了 。同样，表达式：flag2 && flag1，当 flag2 为 false 时，无论 flag1 为 true 或者是 false ，整个表达式都为 false。

最后一点，Java 支持三元操作符（?:），下面的表达式：

condition ? expression1 : expression2;

当条件 condition 为 true 时，整个表达式就取 expression1 的值，条件 condition 为 false 时，整个表达式就取 expression2 的值。

6、括号与运算符级别

下图给出了运算符的优先级别，如果不使用括号，就会按照下图给出的运算符优先级别次序进行计算。