Java 编程从入门到实战：核心语法详解

本文是「Java 编程从入门到实战」系列第二篇，承接开发环境搭建，系统讲解 Java 核心语法体系

一、引言

掌握 Java 核心语法是构建编程逻辑的基础。本文将围绕数据类型、流程控制、方法定义等核心模块展开，通过场景化示例和代码解析，帮助读者建立结构化编程思维，为后续面向对象编程和实战开发筑牢根基。

二、数据类型：编程世界的 “基本元素”

2.1 基本数据类型（Primitive Types）

关键特性：

• 自动类型转换：小范围类型可自动转换为大范围类型（如int→double）

  int num = 10;  
  double result = num;  // 自动转换为10.0  

• 强制类型转换：大范围类型转小范围需显式声明（可能丢失精度）

  double d = 3.9;  
  int i = (int) d;  // 结果为3（直接截断小数部分）  

2.2 引用数据类型（Reference Types）

• 类（Class）：自定义数据类型，如String、自定义Student类

  String name = "Alice";  // String是最常用的引用类型  

• 数组（Array）：存储相同类型数据的集合（本质是对象）
• 接口（Interface）：定义行为规范，不包含具体实现

• 枚举（Enum）：用于定义固定取值的常量集合

核心区别：

基本类型存储值本身，引用类型存储对象地址，默认值为null。

三、运算符与表达式：逻辑运算的 “粘合剂”

3.1 常用运算符分类

（1）算术运算符

（2）关系运算符（结果为 boolean）

int a=5, b=3;  
boolean result = a > b;  // true  
boolean equal = a == b;  // false  

（3）位运算符（针对二进制位操作）

• 按位与（&）：两位都为 1 则为 1，否则为 0

• 按位或（|）：两位至少一个为 1 则为 1

• 异或（^）：两位不同则为 1，相同为 0

• 左移（<<）：向左移动 n 位，相当于乘以 2^n

  int x = 3;  // 二进制11  
  x << 2 → 1100（即12，3×2²=12）  

3.2 运算符优先级

记住核心规则：

1. 括号优先级最高（()）

1. 单目运算符（++、--、!）高于算术运算符

1. 乘除取余（*、/、%）高于加减（+、-）

1. 关系运算符高于逻辑运算符（&&、||）

1. 三目运算符（? :）优先级最低

四、流程控制：程序的 “逻辑方向盘”

4.1 分支结构

（1）if-else 语句

int score = 85;  
if (score >= 90) {  
    System.out.println("优秀");  
} else if (score >= 80) {  
    System.out.println("良好");  
} else {  
    System.out.println("及格");  
}  

（2）switch 语句（JDK 14 + 支持模式匹配）

String season = "春天";  
switch (season) {  
    case "春天" -> System.out.println("万物复苏");  
    case "夏天" -> System.out.println("烈日炎炎");  
    default -> System.out.println("未知季节");  
}  

4.2 循环结构

（1）for 循环（最常用）

// 遍历数组  
int[] numbers = {1, 2, 3, 4, 5};  
for (int i = 0; i < numbers.length; i++) {  
    System.out.print(numbers[i] + " ");  
}  

（2）增强 for 循环（foreach）

// 遍历数组  
int[] numbers = {1, 2, 3, 4, 5};  
for (int i = 0; i < numbers.length; i++) {  
    System.out.print(numbers[i] + " ");  
}  

（3）while/do-while 循环

int i = 1;  
while (i <= 5) {  // 先判断后执行  
    System.out.print(i + " ");  
    i++;  
}  

4.3 跳转语句

• break：跳出当前循环或 switch

• continue：跳过本次循环剩余代码，进入下一次循环

• return：结束方法并返回结果

五、数组与多维数组：数据集合的 “容器”

5.1 一维数组

声明与初始化

// 静态初始化  
int[] scores = {80, 90, 85};  
// 动态初始化  
String[] names = new String[3];  // 长度为3，元素默认值为null  
names[0] = "张三";  

数组特性

• 长度固定，通过数组名.length获取

• 元素类型统一，可存储基本类型或引用类型

• 越界访问会抛出ArrayIndexOutOfBoundsException

5.2 多维数组（以二维数组为例）

// 声明3行2列的二维数组  
int[][] matrix = new int[3][2];  
// 初始化  
matrix[0][0] = 1;  
matrix[0][1] = 2;  
// 遍历  
for (int i = 0; i < matrix.length; i++) {  
    for (int j = 0; j < matrix[i].length; j++) {  
        System.out.print(matrix[i][j] + " ");  
    }  
    System.out.println();  
}  

六、方法：代码复用的 “积木”

6.1 方法定义

/**  
 * 计算两数之和  
 * @param a 第一个数  
 * @param b 第二个数  
 * @return 两数之和  
 */  
public static int add(int a, int b) {  
    return a + b;  
}  

6.2 方法重载（Overload）

同一类中方法名相同，参数列表不同（类型 / 顺序 / 个数）

// 重载add方法，支持浮点型计算  
public static double add(double a, double b) {  
    return a + b;  
}  

6.3 参数传递

• 基本类型：传递值的副本（修改不影响原值）

• 引用类型：传递对象地址（修改会影响原对象）

七、包与命名规范：代码组织的 “户口本”

7.1 包（Package）

• 作用：避免类名冲突，组织代码结构

• 定义：在文件顶部声明包名（通常采用反向域名，如com.ds.cn）

  package com.ds.cn.core;  

• 导入：使用import语句引入其他包的类

  import java.util.Scanner;  // 导入单个类  
  import java.util.*;         // 导入整个包（不推荐）  

7.2 命名规范

八、常见问题与最佳实践

8.1 数据类型陷阱

• 浮点型精度问题：避免直接比较double类型（改用BigDecimal）

• 字符编码：char本质是 Unicode 编码，支持中文等多语言字符

8.2 流程控制优化

• 避免深层嵌套：超过 3 层嵌套时考虑重构（使用方法拆分）

• switch 慎用default：明确所有可能分支，增强代码健壮性

8.3 数组安全操作

• 初始化时指定长度或直接赋值

• 遍历数组前检查null和长度

九、总结与后续规划

核心收获

1. 掌握 8 种基本数据类型与引用类型的本质区别

1. 学会使用运算符构建复杂逻辑表达式

1. 熟练运用分支 / 循环实现流程控制

1. 理解方法重载与参数传递机制

1. 遵循包结构与命名规范组织代码

学习建议

1. 动手练习：编写计算器程序（实现加减乘除、取余、类型转换）

1. 错题整理：记录类型转换错误、数组越界等典型问题

1. 文档阅读：查阅 Java 官方文档，理解String等常用类的 API

系列预告

下一篇将进入面向对象编程核心内容，讲解类与对象、封装继承多态、抽象类与接口等关键概念，带领读者从结构化编程过渡到面向对象思维。关注浩南，获取完整学习路径！

互动思考

你在学习数据类型时遇到过哪些 “反直觉” 的问题？比如char为什么能存储中文？欢迎在评论区分享你的理解，一起攻克语法难点！