java

Java 基础语法

By AI-Writer 11 min read

Java 基础语法

Java 是一门强类型语言，每个变量都必须声明其数据类型。这与 Python 等动态类型语言不同，强类型带来了更好的编译期检查和运行时性能。本文将系统讲解 Java 的数据类型、运算符、控制流程、方法以及数组，帮助你建立扎实的语法基础。

数据类型

Java 的数据类型分为基本类型（Primitive Types）和引用类型（Reference Types）两大类。

基本类型：8 种

基本类型直接存储数值，不通过对象引用访问。它们分为 4 类整数、2 类浮点、1 类字符和 1 类布尔：

类型关键字位宽取值范围默认值
字节型byte8bit-128 ~ 1270
短整型short16bit-32768 ~ 327670
整型int32bit-2³¹ ~ 2³¹-10
长整型long64bit-2⁶³ ~ 2⁶³-10L
单精度浮点float32bit~±3.4×10³⁸0.0f
双精度浮点double64bit~±1.8×10³⁰⁸0.0d
字符型char16bitUnicode 字符’\u0000’
布尔型boolean1bittrue / falsefalse
java
// 整数类型
byte  smallNumber = 100;
short shortNumber = 32000;
int   age = 25;              // 最常用
long  largeNumber = 9223372036854775807L;  // 必须加 L 后缀

// 浮点类型
float temperature = 36.5f;   // 必须加 f/F 后缀
double pi = 3.14159265358979; // 最常用，默认浮点类型

// 字符类型（使用单引号）
char grade = 'A';
char chinese = '中';

// 布尔类型（只有 true 和 false，不能用 0/1 替代）
boolean isStudent = true;
boolean hasPassed = false;

引用类型：3 种

引用类型存储的是对象的内存地址（引用），而非实际值。最常用的三种引用类型是类、数组和接口：

java
// 字符串是引用类型（String 类）
String name = "Alice";
String greeting = new String("Hello");

// 数组是引用类型
int[] scores = {95, 87, 92};
String[] fruits = new String[3];

基本类型 vs 引用类型：基本类型存储在栈内存中，访问效率高；引用类型的数据存储在堆内存中，栈上只保存其引用（地址）。

类型转换

Java 支持不同数据类型之间的转换，分为自动转换（隐式）和强制转换（显式）。

java
// 自动转换：范围小的类型向范围大的类型转换（安全）
int    i = 100;
long   l = i;       // int → long，自动转换
double d = i;       // int → double，自动转换

// 强制转换：范围大的类型向范围小的类型转换（可能丢失精度）
double pi = 3.14159;
int    truncated = (int) pi;  // 结果为 3，小数部分被截断

// 字符串与其他类型的转换
String s = "123";
int     n = Integer.parseInt(s);   // String → int
double  f = Double.parseDouble("3.14"); // String → double
String  back = String.valueOf(n);  // int → String

变量与常量

变量声明

java
// 声明并赋值（最常见）
int count = 0;

// 先声明，后赋值
String name;
name = "Bob";

// 同时声明多个同类型变量
int a = 1, b = 2, c = 3;

常量（final）

使用 final 关键字声明常量，一旦赋值便不可更改：

java
final double TAX_RATE = 0.13;  // 常量命名规范：全大写下划线分隔
final int MAX_RETRY = 3;

// TAX_RATE = 0.15;  // 编译错误：无法给最终变量赋值

常量命名规范：Java 常量通常使用全大写字母，单词间用下划线分隔（MAX_RETRY、BUFFER_SIZE）。

运算符

算术运算符

java
int a = 10, b = 3;

System.out.println(a + b);   // 13，加法
System.out.println(a - b);   // 7，减法
System.out.println(a * b);   // 30，乘法
System.out.println(a / b);   // 3，整数除法（取整）
System.out.println(a % b);   // 1，取余（模运算）

// 复合赋值运算符
int x = 10;
x += 5;    // x = x + 5 → 15
x -= 3;    // x = x - 3 → 12
x *= 2;    // x = x * 2 → 24

// 自增/自减
int i = 5;
System.out.println(i++);  // 5（先使用，后自增）
System.out.println(i);    // 6
System.out.println(++i);  // 7（先自增，后使用）

关系运算符与逻辑运算符

java
int age = 20;

// 关系运算符（返回 boolean）
System.out.println(age > 18);   // true
System.out.println(age == 20);  // true（注意是 == 不是 =）
System.out.println(age != 25);  // true

// 逻辑运算符
boolean isAdult = age >= 18;
boolean hasTicket = true;
System.out.println(isAdult && hasTicket);  // true AND true → true（短路与）
System.out.println(isAdult || hasTicket);  // true OR true → true（短路或）
System.out.println(!isAdult);             // NOT true → false

位运算符（了解即可）

java
int x = 5;   // 二进制：0101
int y = 3;   // 二进制：0011

System.out.println(x & y);   // 1  (0101 & 0011 = 0001)
System.out.println(x | y);   // 7  (0101 | 0011 = 0111)
System.out.println(x ^ y);   // 6  (0101 ^ 0011 = 0110，异或)
System.out.println(~x);      // -6 （按位取反）
System.out.println(x << 1);  // 10 (左移1位，相当于 ×2)
System.out.println(x >> 1);  // 2  (右移1位，相当于 ÷2)

控制流程

if / else 条件判断

java
int score = 85;

// 基本 if
if (score >= 60) {
    System.out.println("及格");
}

// if - else
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

// 三元运算符（简化单层 if-else）
String result = score >= 60 ? "及格" : "不及格";
System.out.println(result);

switch 多分支选择

java
int day = 3;

switch (day) {
    case 1:
        System.out.println("星期一");
        break;  // 不要忘记 break，否则会「贯穿」
    case 2:
        System.out.println("星期二");
        break;
    case 3:
        System.out.println("星期三");
        break;
    // ...
    default:
        System.out.println("无效的星期数");
}

for 循环

java
// 经典 for 循环
for (int i = 0; i < 5; i++) {
    System.out.println("第 " + i + " 次循环");
}

// 遍历数组（增强 for 循环，Java 5+）
String[] fruits = {"苹果", "香蕉", "橙子"};
for (String fruit : fruits) {
    System.out.println(fruit);
}

// 计算 1~100 的和
int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println("1+2+...+100 = " + sum);

while 与 do-while

java
// while：先判断后执行（可能一次都不执行）
int n = 5;
while (n > 0) {
    System.out.println(n);
    n--;
}

// do-while：先执行后判断（至少执行一次）
int m = 5;
do {
    System.out.println(m);
    m--;
} while (m > 0);

循环控制：break 与 continue

java
// break：跳出整个循环
for (int i = 1; i <= 10; i++) {
    if (i == 6) {
        System.out.println("遇到 6，跳出循环");
        break;
    }
    System.out.print(i + " ");
}
// 输出：1 2 3 4 5 遇到 6，跳出循环

// continue：跳过本次循环，继续下一次
for (int i = 1; i <= 5; i++) {
    if (i == 3) {
        continue;  // 跳过 3 的打印
    }
    System.out.print(i + " ");
}
// 输出：1 2 4 5

方法

**方法（Method）**是一段可重复使用的代码块，用于实现特定功能。

方法的定义与调用

java
public class MethodDemo {

    // 无返回值方法
    static void greet(String name) {
        System.out.println("你好，" + name + "！");
    }

    // 带返回值方法
    static int add(int a, int b) {
        return a + b;
    }

    // 带默认返回值的简单计算
    static int max(int a, int b) {
        return (a > b) ? a : b;
    }

    public static void main(String[] args) {
        greet("Alice");          // 调用无返回值方法

        int sum = add(3, 5);     // 调用带返回值方法
        System.out.println("3 + 5 = " + sum);

        int maximum = max(10, 7);
        System.out.println("较大值是 " + maximum);
    }
}

方法重载（Overloading）

方法重载指在同一个类中，方法名相同但参数列表不同（参数个数、类型或顺序不同）的情况。编译器通过参数列表决定调用哪个方法。

java
// 方法重载示例
static int add(int a, int b) {
    return a + b;
}

static double add(double a, double b) {
    return a + b;
}

static int add(int a, int b, int c) {
    return a + b + c;
}

// 调用时编译器自动匹配
System.out.println(add(1, 2));        // 调用第一个 → 3
System.out.println(add(1.5, 2.5));    // 调用第二个 → 4.0
System.out.println(add(1, 2, 3));     // 调用第三个 → 6

方法重载 vs 方法重写：重载发生在同一个类中，参数列表必须不同；重写发生在父子类之间（继承场景），方法签名必须完全相同。

数组

数组是相同类型元素的固定长度序列，是最基础的线性数据结构。

数组的声明与初始化

java
// 方式一：声明并指定长度（元素有默认值）
int[] scores = new int[5];      // int 默认值 0

// 方式二：声明并直接赋值（确定长度）
String[] names = {"Alice", "Bob", "Carol"};

// 方式三：先声明，后赋值
int[] data = new int[]{10, 20, 30, 40};

数组的访问与遍历

java
int[] nums = {78, 92, 85, 61};

System.out.println(nums[0]);    // 第一个元素
System.out.println(nums.length); // 数组长度：4

// 修改元素
nums[1] = 95;

// 普通 for 循环
for (int i = 0; i < nums.length; i++) {
    System.out.print(nums[i] + " ");
}
System.out.println();

// 增强 for 循环（只读遍历）
for (int num : nums) {
    System.out.print(num + " ");
}

二维数组

java
// 定义一个 3 行 4 列的矩阵
int[][] matrix = {
    {1, 2, 3, 4},
    {5, 6, 7, 8},
    {9, 10, 11, 12}
};

// 遍历二维数组
for (int row = 0; row < matrix.length; row++) {
    for (int col = 0; col < matrix[row].length; col++) {
        System.out.printf("%4d", matrix[row][col]);
    }
    System.out.println();
}

完整示例：成绩统计

java
public class ScoreStats {
    public static void main(String[] args) {
        int[] scores = {78, 92, 85, 61, 95, 73, 88, 100, 55, 67};

        int total = 0;
        int max = scores[0];
        int min = scores[0];

        for (int score : scores) {
            total += score;
            if (score > max) max = score;
            if (score < min) min = score;
        }

        double average = (double) total / scores.length;

        System.out.println("===== 成绩统计 =====");
        System.out.println("人数：" + scores.length);
        System.out.println("总分：" + total);
        System.out.println("平均分：" + String.format("%.2f", average));
        System.out.println("最高分：" + max);
        System.out.println("最低分：" + min);
    }
}
bash
===== 成绩统计 =====
人数：10
总分：794
平均分：79.40
最高分：100
最低分：55

小结

  • Java 有 8 种基本类型和多种引用类型，整数默认用 int，浮点默认用 double
  • final 关键字用于声明常量，命名使用全大写下划线风格
  • 控制流程包括条件分支（if/switch）、循环（for/while/do-while）和跳转（break/continue）
  • 方法封装可复用逻辑，支持重载（同名的不同参数版本）
  • 数组是固定长度的同类型元素集合，索引从 0 开始

学完基础语法，下一节我们将进入 Java 最重要的部分——面向对象编程（OOP），理解类、对象与封装的核心理念。

#java #数据类型 #运算符 #控制流程 #方法 #数组

评论

A

Written by

AI-Writer

Related Articles

java
#5

异常处理机制

深入讲解 Java 异常体系、try-catch-finally 语法、throws 与 throw 关键字、自定义异常，以及 Java 17+ 中异常处理的改进

Read More
java
#8

JDBC 与数据库交互

详解 JDBC 编程五步曲：加载驱动、建立连接、执行 SQL、处理结果集，以及 PreparedStatement 防注入、事务控制和连接池原理

Read More
Back to All Articles