Java 基础语法

参考指导书 2.1 基础语法

学习清单

  • JDK 安装与环境配置
  • 第一个 Java 程序：Hello World
  • 基本数据类型（int, long, float, double, boolean, char, byte, short）
  • 变量与常量
  • 运算符（算术、关系、逻辑、位、三元）
  • 流程控制（if-else, switch, for, while, do-while）
  • 数组（一维数组、二维数组）

1. JDK 安装与环境配置

JDK vs JRE

概念 全称 作用
JDK Java Development Kit 开发者工具包，包含 javac（编译器） + java（运行器） + JRE
JRE Java Runtime Environment 运行 Java 程序的环境，只有 java 没有 javac
JVM Java Virtual Machine 执行字节码的虚拟机，JDK 和 JRE 都包含

编译与运行流程

.java 源文件  ──javac 编译──▶  .class 字节码  ──java 运行──▶  JVM 执行

环境检查

java -version       # 查看 JDK 版本
javac -version      # 查看编译器版本

2. 第一个 Java 程序：Hello World（程序基本规则详解）

最小代码

// HelloWorld.java
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

逐行解析

  1. public class HelloWorld

    • public：访问修饰符，表示这个类对外公开
    • class：声明一个类，Java 中所有代码都必须放在类中
    • HelloWorld：类名，必须与文件名完全一致（大小写敏感）

  2. public static void main(String[] args)

    • public：main 方法必须公开，JVM 才能调用
    • static：静态方法，JVM 不需要创建对象就能直接调用
    • void：main 方法不返回任何值
    • main：固定方法名，JVM 固定入口，名字不能改
    • String[] args：命令行参数数组

  3. System.out.println("Hello, World!")

    • System：JDK 内置类
    • out：System 类的静态成员，代表标准输出流
    • println：打印一行并换行
    • "Hello, World!"：字符串字面量，双引号包裹

编译与运行

javac -encoding UTF-8 HelloWorld.java    # 编译生成 HelloWorld.class
java HelloWorld                           # 运行（不带 .class 后缀）

类名与文件名的关系

  • 带 public 的类的名称必须与 .java 文件名完全一致
  • 一个 .java 文件最多只能有一个 public class
  • 可以有多个非 public 类

为什么是 main 方法？

JVM 启动时，固定找 public static void main(String[] args) 作为程序入口。签名必须严格匹配——少一个参数、多一个返回值、不用 static 修饰都会导致 “找不到 main 方法” 错误。

System.out.print("不换行");
System.out.println("换行");       // ln = line
System.out.printf("格式化: %s %d", "age", 18);

3. 基本数据类型

Java 是强类型语言：每个变量必须先声明类型才能使用。

8 种基本类型（Primitive Types）

类型 大小 范围 示例
byte 1 字节 -128 ~ 127 byte b = 100;
short 2 字节 -32768 ~ 32767 short s = 30000;
int 4 字节 -2³¹ ~ 2³¹-1（约 ±21 亿） int i = 100;
long 8 字节 -2⁶³ ~ 2⁶³-1 long l = 100L; ← 必须加 L
float 4 字节 约 7 位有效数字 float f = 3.14f; ← 必须加 f
double 8 字节 约 15 位有效数字 double d = 3.14;
char 2 字节 0 ~ 65535（Unicode） char c = 'A';
boolean 1 位（JVM 相关） true / false boolean b = true;

变量声明与赋值

int age;                // 声明
age = 18;               // 赋值
int score = 100;        // 声明 + 赋值（初始化）
score = 200;            // 重新赋值

常量

final double PI = 3.14159;   // final 修饰，值不能改
// PI = 3.14;                // 编译错误！

类型转换

// 自动转换（小 → 大）：安全，自动完成
int i = 100;
long l = i;             // int 自动升级为 long

// 强制转换（大 → 小）：可能溢出，需手动指定
long big = 1000L;
int small = (int) big;  // 必须写 (int)，否则编译报错

// float 转 int：小数部分直接截断
float f = 3.99f;
int n = (int) f;        // n = 3，不是 4

引用类型 vs 基本类型

// 基本类型：存值本身
int a = 10;
int b = a;      // b = 10，独立拷贝

// 引用类型：存对象地址（String 是引用类型）
String s1 = "Hello";
String s2 = s1;   // s2 和 s1 指向同一个 "Hello" 对象

4. 运算符

算术运算符

int a = 10, b = 3;
a + b   // 13  加
a - b   // 7   减
a * b   // 30  乘
a / b   // 3   除（整数除法，结果仍是整数，小数被丢弃）
a % b   // 1   取余（取模）

自增自减（注意前置后置区别）

int x = 5;
int y = x++;   // y=5, x=6  后置：先赋值再自增
int z = ++x;   // z=7, x=7  前置：先自增再赋值

关系运算符（结果 boolean）

a == b  // 等于
a != b  // 不等于
a > b   // 大于
a < b   // 小于
a >= b  // 大于等于
a <= b  // 小于等于

逻辑运算符

boolean x = true, y = false;
x && y  // false  AND（短路：左边为 false 时不计算右边）
x || y  // true   OR （短路：左边为 true 时不计算右边）
!x      // false  NOT

三元运算符（一行 if-else）

int max = (a > b) ? a : b;   // 如果 a>b 取 a，否则取 b

5. 流程控制

if-else

int score = 85;
if (score >= 90) {
    System.out.println("A");
} else if (score >= 60) {
    System.out.println("B");
} else {
    System.out.println("C");
}

switch

int day = 3;
switch (day) {
    case 1: System.out.println("Mon"); break;
    case 2: System.out.println("Tue"); break;
    default: System.out.println("Other");
}
// 漏写 break 会 "穿透" 到下一个 case

for 循环

for (int i = 0; i < 5; i++) {   // 初始化; 条件; 步进
    System.out.println(i);       // 输出 0 1 2 3 4
}

// 增强 for：遍历数组/集合
for (int num : new int[]{1, 2, 3}) {
    System.out.println(num);     // 输出 1 2 3
}

while / do-while

int i = 0;
while (i < 3) {         // 先判再执行，可能一次都不执行
    i++;
}

do {                    // 先执行再判，至少执行一次
    i++;
} while (i < 3);

break / continue

for (int i = 1; i <= 10; i++) {
    if (i == 5) break;      // 直接退出整个循环
}
for (int i = 1; i <= 5; i++) {
    if (i == 3) continue;   // 跳过本次循环，进入下一次
}

6. 数组

一维数组

// 三种创建方式
int[] arr1 = {1, 2, 3, 4, 5};            // 直接初始化
int[] arr2 = new int[]{6, 7, 8};          // new + 初始化
int[] arr3 = new int[4];                  // 只指定长度，默认全 0

// 长度
arr1.length   // 5

// 访问
arr1[0] = 100;   // 改第一个元素
int v = arr1[1]; // 读第二个元素
// arr1[5]       // 越界！运行时抛出 ArrayIndexOutOfBoundsException

二维数组

int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6}
};
matrix.length      // 2（行数）
matrix[0].length   // 3（第 0 行列数）
matrix[0][1]       // 2（第 0 行第 1 列）

关键记忆点

  1. 文件命名：public class 名必须与文件名一致
  2. 入口方法：public static void main(String[] args) 是 JVM 唯一的入口
  3. 大小写敏感：Java 严格区分大小写（String ≠ string）
  4. 每条语句结束要写分号 ;
  5. 数组越界编译不报错、运行时报错
  6. long 字面量加 L，float 字面量加 f
  7. == 比较基本类型比值，比较引用类型比地址——String 判断内容用 equals()