2.1 - 变量和常量

2.1.1 - 字面量

2.1.2 - 变量的分类和作用域

Java 变量按声明位置分为四大类：局部变量、实例变量、静态变量和参数。其中实例变量和静态变量统称为字段（field），或成员变量。

class Student {
    String name;              // 实例变量
    static int count = 0;     // 静态变量
 
    void study(int hours) {   // hours：参数
        int minutes = hours * 60; // 局部变量
    }
}

关于不同类型变量的作用域（Scope）：

• 局部变量：作用域仅限于定义它的那一对 {} 内部；
• 实例变量和静态变量（字段）：受访问修饰符的影响（将在面向对象部分介绍）；
• 参数：作用域仅限于方法内部。

2.1.3 - 变量的声明、初始化和赋值

一、声明、初始化和赋值

Java 变量的使用通常包括三个操作：声明（Declaration）、初始化（Initialization）和赋值（Assignment）。

• 声明：必须指定变量的类型与名称，可不给初始值；
• 初始化：初始化指变量首次获得初始值的过程；
• 赋值：与 C 一致，对于普通变量，可以通过赋值运算符 = 修改其保存的值。

int age;
double score = 95.5;
char gender = 'M';
 
// 允许在一条声明语句中声明多个相同类型的变量
int a = 10, b, c = 30;

二、确定赋值规则

对于局部变量，因为无默认值，所以 Java 要求在读取变量之前，必须能够确定该变量已经被赋值。这称为确定赋值（Definite Assignment）。

public class Main {
    public static void main(String[] args) {
        int age;
 
        if (Math.random() > 0.5) {
            age = 20;
        }
 
        System.out.println(age); // 编译错误
    }
}

int age;
 
if (Math.random() > 0.5) {
    age = 20;
} else {
    age = 30;
}
 
System.out.println(age); // 正确

public class Main {
    static int age;
 
    public static void main(String[] args) {
        System.out.println(age); // 输出 0
    }
}

2.1.4 - 局部变量类型推断（var）

从 Java 10 开始，Java 支持使用 var 声明具有类型推断能力的局部变量。

• 必须在声明时提供初始化表达式。
• 不能用 null 作为唯一的初始化表达式。
• 不能用来声明普通字段或方法参数。
• 一次 var 声明只能声明一个变量。
• 推断后的类型是固定的，并不是动态类型。

var x = 10;   // int
var y = 10L;  // long
var z = 10.0; // double
var price = 19.99f; // float
var name = "Alice"; // String
 
var obj = null;     // 错误：无法推断类型
var score;          // 错误：缺少初始化表达式
var a = 1, b = 2;   // 错误：不能这样同时声明两个变量

2.1.5 - 常量

final int MAX_SIZE = 100;

• final：表示该变量只能被赋值一次（可以不立即赋值）。

• int：变量的数据类型。

• MAX_SIZE：变量名；一般情况下全部字母大写，单词之间使用下划线分隔，不过局部常量仍可以使用小驼峰命名法。

• 100：初始值，也是一个整数字面量。

2.2 - 数据类型

Java 是一种静态类型语言（Statically Typed Language），变量的类型在编译时就需要确定，不能随意改变。

Java 的数据类型可以分为两大类：

• 基本数据类型（Primitive Types）：直接表示数值、字符或布尔值，共有 8 种。
• 引用数据类型（Reference Types）：通过引用访问对象或数组，例如类、接口、数组等。

2.2.1 - Java 基本数据类型

String emoji = "😀";
System.out.println(emoji.length()); // 2

int a = 1;
 
if (a) {   // 编译错误
    System.out.println("Hello");
}

2.2.2 - Java 引用数据类型

除了 8 种基本类型，Java 中的其他大多数数据类型都是引用类型，包括字符串。

• 引用类型变量可以保存 null，表示当前没有引用任何对象；
• 引用类型赋值 = 引用的复制（指向同一对象）
• Java 只有值传递（pass by value），在给方法传参时，传入的是引用的副本（可改变所指对象的内容，但无法修改该指向）。

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;      // arr1 和 arr2 指向同一个数组对象
arr2[0] = 99;
System.out.println(arr1[0]); // 99
 
String s1 = new String("hi");
String s2 = new String("hi");
s1 == s2        // false（不同对象）
s1.equals(s2)   // true （内容相同）
 
String s = "a";
String t = s;
s = s + "b";    // s + "b" 是一个新的对象，因为 s 所指的对象 "a" 无法修改，t 仍是 "a"

2.3 - 基本数据类型的类型转换

2.3.1 - 赋值和传参时的转换

一、自动类型转换（隐式 / 拓宽转换）

• char 可以自动转 int 及更宽类型；

• byte / short 不能自动转 char，因为 char 是无符号的；

• int 转 float、long 转 float、long 转 double 可能丢失精度。

int a = 100;
long b = a;     // int 自动转换为 long
double d = a;   // int 自动转换为 double

二、强制类型转换（显式 / 窄化转换）

• 语法：(目标类型) 变量名。

• 转换方法：整数直接截断高位、浮点转整数直接丢弃小数部分。

• boolean 不能与任何数值基本类型进行类型转换。

double d = 99.99;
int i = (int) d; // 小数部分直接被舍弃，i 的值为 99
 
int bigNum = 300;
byte b = (byte) bigNum; // byte 范围是 -128 ~ 127，转换后会发生溢出，结果为 44

2.3.2 - 表达式中的类型提升

一、一元数值提升（Unary Numeric Promotion）

当 byte、short 或 char 参与某些一元运算时，会先提升为 int（例如一元正号 +）。

byte a = 10;
 
int b = +a;    // 正确
byte c = +a;   // 编译错误，因为 +a 的结果是 int 类型

二、二元数值提升（Binary Numeric Promotion）

适用于大部分二元运算符：

• 算术运算符：+ - * / %

• 比较运算符：<、<=、>、>=

• 位运算符：& | ^

• 数值相等运算符：==、!=

规则顺序：

1. 如果任一操作数是 double，另一个操作数转换为 double；

2. 否则，如果任一操作数是 float，另一个操作数转换为 float；

3. 否则，如果任一操作数是 long，另一个操作数转换为 long；

4. 否则，两个操作数都转换为 int（也就是在处理 byte/short的运算时，必须转为 int，这是因为 JVM 并没有 byte/short 的算术指令）

byte a = 1;
byte b = 2;
byte c = a + b;         // 编译错误
byte c = (byte)(a + b); // 编译成功
 
int d = 10;
long e = 20L;
long f = d + e; // 结果类型为 long
 
float g = 3.14F;
double h = 2.0;
double i = g + h; // 结果类型为 double

需特别注意整数除法：

int a = 5;
int b = 2;
double c = a / b; // 2.0
/**
    因为 a / b 的两个操作数都是 int，所以它执行整数除法，结果是整数 2。
    之后，再将 2 自动转换为 double，得到 2.0。
**/
double c = (double) a / b; // 2.5

2.4 - 运算符

Java 的运算符与 C 语言有很多相似之处，但在整数除法、字符串拼接、逻辑运算、位运算、类型转换和对象比较等方面，有一些值得特别注意的规则。

2.4.1 - 表达式和运算符概述

一、表达式的组成

int result = a + b;

• a、b：操作数（Operand）

• +：运算符（Operator）

• a + b：表达式（Expression）

• =：赋值运算符，将右侧表达式的结果赋给左侧变量（整个赋值也是一个表达式）

二、运算符的分类

2.4.2 - 算术运算符

• 运算结果取决于参与运算的操作数类型，而不是接收结果的变量类型；
• Java 取余运算：$a \% b = a - (a / b) \times b$ （期中 / 是向 0 截断的整数除法）；
• 与 C 不同，Java 的 % 还可以用于浮点数。

System.out.println(10 / 3);     // 3
System.out.println(10.0 / 3);   // 3.3333333333333335
System.out.println(-10 / 3);    // -3，向 0 截断，而不是向下取整或四舍五入
 
double a = 10 / 3;
double b = 10.0 / 3;
 
System.out.println(a);  // 3.0
System.out.println(b);  // 3.3333333333333335
 
System.out.println(10 % 3);    // 1
System.out.println(-10 % 3);   // -1
System.out.println(10 % -3);   // 1
System.out.println(-10 % -3);  // -1
 
System.out.println(5.5 % 2.0); // 1.5

2.4.3 - 字符串拼接

Java 中的 + 还可用于字符串拼接。

System.out.println("Hello" + " World");
// Hello World
 
System.out.println(1 + 2 + "3");  // "33"
System.out.println("1" + 2 + 3);  // "123"，因为按顺序会先得到“12”
System.out.println("1" + (2 + 3)); // "15"

2.4.4 - 自增和自减运算符

Java 中，自增和自减运算可以作用于 byte、short、char 等类型，并且不需要显式类型转换：

• 但 Java 本身无法对这三类变量进行算术运算，所以会先将其自动提升为 int 类型；
• 运算结束后，再自动将结果强制转换回原本的类型；
• 所以，即使运算结果超过该类型的表数范围，也不产生编译错误，而是溢出。

byte b = 10;
b = b + 1; // 编译错误
b++;       // 编译成功，等价于 b = (byte)(b + 1);

2.4.5 - 赋值运算符

一、基本赋值运算符

• 赋值表达式的类型是左侧变量的类型；赋值表达式的值是赋值完成后左侧变量的值。；
• 并且 Java 的赋值运算符都具有右结合性（运算符的结合性决定同优先级运算符连续出现时如何分组），所以 Java 支持连续赋值。

a = b = c;
// 等价于
a = (b = c);
// 而不是 (a = b) = c; 
// 因为 (a = b) 是一个赋值表达式的结果，不是变量，不能作为赋值左操作数。

二、复合赋值运算符

与自增、自减运算符类似，Java 的复合赋值运算符隐含了向左侧变量类型的强制转换。

byte a = 10;
 
a = a + 5;  // 编译错误
a += 5;     // 正确，相当于 a = (byte) (a + 5);

2.5 - 基本输入输出