Java 基础语法教学

Java 程序以类为单位组织，代码写在类的花括号内。源文件先由 javac 编译成字节码（.class）， 再由 JVM 解释执行——这正是 Java 平台无关的原因：同一份字节码可以在任何装有 JVM 的机器上运行。 程序的入口是固定的 main 方法，JVM 从这里开始执行第一条语句。

// 文件名必须与 public 类名完全一致：Hello.java
public class Hello {
    public static void main(String[] args) {   // 程序入口，签名固定
        System.out.println("Hello, Java");     // 向控制台输出并换行
    }
}

// 编译与运行（命令行）
// javac Hello.java   → 生成 Hello.class（字节码）
// java  Hello        → JVM 执行（注意不带 .class 后缀）

变量是内存中的一块存储区域，类型决定它占多大空间、能放什么值。 Java 有 8 种基本类型，它们的字节数固定不变（不像 C/C++ 那样随平台变化）。 需要区分的是：成员变量有默认值，而局部变量必须先赋值才能使用。

// 标识符：由字母、$、_ 开头，后可跟数字；区分大小写；不能是关键字
// 习惯：类名首字母大写，变量/方法名首字母小写，常量全大写

boolean flag = true;        // true / false
byte    b = 127;            // 1 字节，-128 ~ 127
short   s = 32767;          // 2 字节
int     i = 2147483647;     // 4 字节，整数的默认类型
long    l = 100L;           // 8 字节，字面量加后缀 L
float   f = 3.14F;          // 4 字节，必须加 F，否则编译错误
double  d = 3.1415926;      // 8 字节，浮点的默认类型
char    c = 'A';            // 2 字节，单引号，Unicode

// 字面量写法
int hex = 0xFF, bin = 0b1010;      // 十六进制 / 二进制
long big = 1_000_000L;             // 下划线仅提高可读性
char nl = '\n', uni = '中';         // 转义字符与 Unicode 字符

小范围类型可以自动转换成大范围类型（不会丢精度）；反过来必须强制转换，且可能丢精度或溢出。 表达式中不同类型混合运算时，整体会先提升为其中最高的类型。

// 自动转换方向：byte → short → char → int → long → float → double
int i = 10;
double d = i;             // 自动转换，安全

// 强制转换：可能丢失精度
double x = 3.99;
int n = (int) x;          // 直接截断，结果是 3（不是四舍五入）
byte bb = (byte) 300;     // 溢出，结果是 44

// 混合运算：整体提升为最高类型
int a = 5, b = 2;
System.out.println(a / b);        // 2，整数除法会截断
System.out.println(a / (double)b);// 2.5，先把其中一个提升为浮点

运算符决定表达式如何求值。需要特别理解两点： ①短路求值——&& 左侧为 false 时右侧不再计算，|| 左侧为 true 时同理； ②自增位置——i++ 先用后加，++i 先加后用。

int a = 10, b = 3;
System.out.println(a / b);       // 3   整除
System.out.println(a % b);       // 1   取余
System.out.println(a++);         // 10  先用后加（此后 a 变为 11）
System.out.println(++a);         // 12  先加后用

boolean p = true, q = false;
System.out.println(p && q);      // false，左侧为 false 时右侧不求值
System.out.println(p || q);      // true ，左侧为 true 时右侧不求值

int x = 0b1100;
System.out.println(x & 0b1010);  // 8   按位与
System.out.println(x | 0b1010);  // 14  按位或
System.out.println(x ^ 0b1010);  // 6   按位异或
System.out.println(x << 2);      // 左移 2 位（相当于乘 4）

int max = (a > b) ? a : b;       // 三目运算符
a += 5;                          // 复合赋值（隐含强制转换）

顺序结构只能从上往下执行；分支让程序按条件选择路径，循环让一段代码重复执行。 switch 适合"一个变量取离散的若干值"的场景，注意每个 case 结束要写 break，否则会继续向下执行（穿透）。 for-each 是最简洁的只读遍历方式。

// 分支
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// switch：支持 byte/short/char/int、String、枚举
switch (grade) {
    case 'A': System.out.println("90 以上"); break;   // 漏写 break 会穿透
    case 'B': System.out.println("80 以上"); break;
    default : System.out.println("其它");
}

// while / do-while
while (n > 0) { sum += n; n--; }
do { sum += n; n--; } while (n > 0);        // 至少执行一次

// for 与增强 for
for (int k = 0; k < arr.length; k++) { sum += arr[k]; }
for (int v : arr) { sum += v; }             // for-each，只读遍历最方便

// break / continue
for (int k = 0; k < 10; k++) {
    if (k == 3) continue;                   // 跳过本次循环
    if (k == 8) break;                      // 结束整个循环
}
outer:                                       // 标签：跳出多层循环
for (int i = 0; i < 3; i++)
    for (int j = 0; j < 3; j++)
        if (i * j > 2) break outer;

数组用来存放一组同类型数据。声明时用 int[] a，创建时用 new int[5] 指定长度， 创建后长度固定不变。数组变量保存的是引用，把它赋给另一个变量只是复制地址，两个变量指向同一块数据。 二维数组本质是"数组的数组"，所以每行的长度可以不同。

int[] a = new int[5];          // 创建，元素默认值为 0
int[] b = {1, 2, 3, 4, 5};     // 静态初始化
int[][] m = new int[3][4];     // 3 行 4 列
int[][] m2 = {{1,2},{3,4,5}};  // 每行长度可不同

System.out.println(a.length);    // 5，length 是属性不是方法
System.out.println(m.length);    // 3（行数）
System.out.println(m[0].length); // 4（第一行的列数）

for (int v : b) { System.out.print(v + " "); }
System.out.println(Arrays.toString(b));   // [1, 2, 3, 4, 5]
Arrays.sort(b);                            // 升序排序
int[] copy = Arrays.copyOf(b, b.length);   // 复制（新数组）

输入用 Scanner（在 java.util 包中，需要 import），输出用 System.out。 注意 next() 读到空白符为止，nextLine() 读一整行——二者混用是初学者的经典坑： nextInt() 之后紧跟 nextLine() 会读到空行。

import java.util.Scanner;

Scanner sc = new Scanner(System.in);
int    n  = sc.nextInt();
double d  = sc.nextDouble();
String s  = sc.next();        // 读到空白符为止
String ln = sc.nextLine();    // 读一整行
sc.close();

// 输出
System.out.print("不换行");
System.out.println("换行");
System.out.printf("%d %.2f %s%n", n, d, s);   // 格式化输出
// 格式符：%d 整数  %f 浮点  %.2f 保留两位  %s 字符串  %c 字符  %b 布尔

String 是不可变对象：任何"修改"都会产生新的字符串，原对象不变。 因此在循环中反复拼接字符串会产生大量临时对象，这种场景应使用 StringBuilder。 比较内容用 equals，== 只比较引用地址。

String s = "Hello";
s.length();                    // 5
s.equals("Hello");             // true，比较内容用 equals
s.equalsIgnoreCase("hello");   // 忽略大小写
s.charAt(0);                   // 'H'
s.substring(1, 3);             // "el"，左闭右开
s.indexOf("ll");               // 2，未找到返回 -1
s.trim();                      // 去掉首尾空白
s.toUpperCase();               // "HELLO"，原串不变
String[] parts = "a,b,c".split(",");
String.valueOf(123);           // "123"

StringBuilder sb = new StringBuilder();   // 频繁拼接时用
sb.append("a").append(1).reverse();