Java 基础语法

本章将介绍 Java 的基础语法，包括变量、数据类型和运算符。

第一个程序

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

代码解释

• public class Main：声明一个公共类
• public static void main(String[] args)：主方法，程序入口
• System.out.println()：打印内容并换行

变量

声明变量

// 声明变量（类型 + 变量名）
int age;
String name;
double price;

// 声明并赋值
int count = 10;
String city = "北京";

变量命名规则

1. 由字母、数字、下划线和美元符号组成
2. 不能以数字开头
3. 区分大小写
4. 不能使用 Java 关键字
5. 建议使用驼峰命名法

// 合法的变量名
int userName = "张三";
int age1 = 20;
double _score = 95.5;
String $element = "元素";

// 非法的变量名
// int 1name = "错误";    // 不能以数字开头
// String class = "类";  // 不能使用关键字

常量

使用 final 关键字声明常量：

final double PI = 3.14159;
final String APP_NAME = "我的应用";

数据类型

基本数据类型

整数类型

类型	存储空间	取值范围
byte	1 字节	-128 ~ 127
short	2 字节	-32768 ~ 32767
int	4 字节	-2147483648 ~ 2147483647
long	8 字节	-9223372036854775808 ~ 9223372036854775805

byte b = 100;
short s = 1000;
int i = 100000;
long l = 1000000L;  // 需要加 L 后缀

浮点数类型

类型	存储空间	精度
float	4 字节	单精度
double	8 字节	双精度

float f = 3.14f;    // 需要加 f 后缀
double d = 3.14159;

字符类型

char c = 'A';
char chinese = '中';

布尔类型

boolean isActive = true;
boolean isDeleted = false;

引用数据类型

// 字符串
String str = "Hello";

// 数组
int[] arr = {1, 2, 3};

// 类
String name = "张三";

数组

数组是存储固定大小相同类型元素的容器。数组在 Java 中是对象，存储在堆内存中。

数组声明与初始化

声明数组

// 推荐方式：类型后跟[]
int[] numbers;
String[] names;

// 也可以这样声明（不推荐）
int numbers[];  // 可读性较差

初始化数组

方式一：静态初始化（直接指定元素）

// 声明并初始化
int[] numbers = {1, 2, 3, 4, 5};
String[] names = {"张三", "李四", "王五"};

// 先声明后初始化（需要 new 关键字）
int[] arr;
arr = new int[]{1, 2, 3, 4, 5};

方式二：动态初始化（指定长度）

// 创建长度为 5 的数组，元素为默认值
int[] numbers = new int[5];       // 元素默认为 0
String[] names = new String[3];   // 元素默认为 null
boolean[] flags = new boolean[4]; // 元素默认为 false

// 动态初始化后可以逐个赋值
numbers[0] = 10;
numbers[1] = 20;

默认值

当数组使用动态初始化时，元素会有默认值：

数据类型	默认值
byte, short, int, long	0
float, double	0.0
char	'\u0000'（空字符）
boolean	false
引用类型（类、接口、数组）	null

访问数组元素

int[] numbers = {10, 20, 30, 40, 50};

// 通过索引访问（索引从 0 开始）
System.out.println(numbers[0]);   // 10（第一个元素）
System.out.println(numbers[4]);   // 50（最后一个元素）

// 修改元素
numbers[0] = 100;

// 获取数组长度
int length = numbers.length;      // 5

// 遍历数组
// 方式1：普通 for 循环
for (int i = 0; i < numbers.length; i++) {
    System.out.println("索引 " + i + ": " + numbers[i]);
}

// 方式2：增强 for 循环（for-each）
for (int num : numbers) {
    System.out.println(num);
}

数组越界异常

访问不存在的索引会抛出 ArrayIndexOutOfBoundsException：

int[] arr = {1, 2, 3};
// System.out.println(arr[3]);  // 错误！索引范围是 0-2

// 安全访问
if (index >= 0 && index < arr.length) {
    System.out.println(arr[index]);
}

多维数组

Java 中的多维数组实际上是"数组的数组"。

二维数组

// 静态初始化
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 动态初始化
int[][] arr = new int[3][4];  // 3行4列

// 访问元素
System.out.println(matrix[0][0]);  // 1
System.out.println(matrix[1][2]);  // 6

// 获取行数和列数
int rows = matrix.length;          // 3
int cols = matrix[0].length;       // 3

// 遍历二维数组
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();
}

// 使用增强 for 循环
for (int[] row : matrix) {
    for (int num : row) {
        System.out.print(num + " ");
    }
    System.out.println();
}

不规则数组（锯齿数组）

每行的列数可以不同：

// 每行列数不同
int[][] jagged = new int[3][];
jagged[0] = new int[]{1, 2};           // 2列
jagged[1] = new int[]{3, 4, 5};        // 3列
jagged[2] = new int[]{6, 7, 8, 9};     // 4列

// 或者直接初始化
int[][] jagged2 = {
    {1, 2},
    {3, 4, 5},
    {6, 7, 8, 9}
};

Arrays 工具类

java.util.Arrays 提供了丰富的数组操作方法：

import java.util.Arrays;

int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};

// 转换为字符串
System.out.println(Arrays.toString(arr));  // [3, 1, 4, 1, 5, 9, 2, 6]

// 排序（原地排序，修改原数组）
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));  // [1, 1, 2, 3, 4, 5, 6, 9]

// 二分查找（数组必须先排序）
int index = Arrays.binarySearch(arr, 5);   // 返回索引
int notFound = Arrays.binarySearch(arr, 10); // 返回负数

// 填充
int[] filled = new int[5];
Arrays.fill(filled, 100);
System.out.println(Arrays.toString(filled));  // [100, 100, 100, 100, 100]

// 部分填充
int[] partial = new int[10];
Arrays.fill(partial, 2, 6, 99);  // 索引2到5填充99

// 复制数组
int[] copy1 = Arrays.copyOf(arr, arr.length);     // 完整复制
int[] copy2 = Arrays.copyOf(arr, 10);             // 扩展（多出部分填充默认值）
int[] copy3 = Arrays.copyOfRange(arr, 2, 6);      // 复制索引2到5

// 比较数组
int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a.equals(b));               // false（比较引用）
System.out.println(Arrays.equals(a, b));       // true（比较内容）

// 比较数组（Java 9+）
// Arrays.compare(a, b) 返回：负数(a<b)、0(a==b)、正数(a>b)

// 数组转流（Java 8+）
Arrays.stream(arr).forEach(System.out::println);
int sum = Arrays.stream(arr).sum();

// 并行排序（大型数组效率更高）
int[] largeArray = new int[1000000];
Arrays.parallelSort(largeArray);

二维数组的 Arrays 操作

int[][] matrix = {
    {3, 1, 2},
    {6, 5, 4},
    {9, 8, 7}
};

// 转换为字符串
System.out.println(Arrays.deepToString(matrix));
// 输出: [[3, 1, 2], [6, 5, 4], [9, 8, 7]]

// 深度比较
int[][] other = {{3, 1, 2}, {6, 5, 4}, {9, 8, 7}};
System.out.println(Arrays.deepEquals(matrix, other));  // true

数组与集合转换

import java.util.Arrays;
import java.util.List;
import java.util.ArrayList;

// 数组转 List
String[] array = {"a", "b", "c"};

// 方式1：Arrays.asList() - 固定大小的 List
List<String> list1 = Arrays.asList(array);
// list1.add("d");  // 不支持！会抛出 UnsupportedOperationException
list1.set(0, "A");  // 可以修改元素

// 方式2：创建新的 ArrayList - 可变大小
List<String> list2 = new ArrayList<>(Arrays.asList(array));
list2.add("d");     // 支持

// 方式3：Java 9+ List.of()
List<String> list3 = List.of(array);  // 不可变 List

// List 转数组
List<String> list = new ArrayList<>();
list.add("x");
list.add("y");
list.add("z");

// 方式1：传入类型相同的数组
String[] arr1 = list.toArray(new String[0]);

// 方式2：指定大小的数组
String[] arr2 = list.toArray(new String[list.size()]);

数组拷贝

// System.arraycopy() - 原生方法，效率最高
int[] src = {1, 2, 3, 4, 5};
int[] dest = new int[5];
System.arraycopy(src, 0, dest, 0, src.length);

// Arrays.copyOf() - 内部使用 System.arraycopy
int[] copy = Arrays.copyOf(src, src.length);

// Arrays.copyOfRange() - 复制范围
int[] range = Arrays.copyOfRange(src, 1, 4);  // 索引1到3

// clone() - 创建数组副本
int[] cloned = src.clone();

数组实用技巧

// 1. 查找最大值/最小值
int[] arr = {3, 1, 4, 1, 5, 9, 2, 6};
int max = arr[0], min = arr[0];
for (int num : arr) {
    if (num > max) max = num;
    if (num < min) min = num;
}

// 使用 Stream（Java 8+）
int maxVal = Arrays.stream(arr).max().getAsInt();
int minVal = Arrays.stream(arr).min().getAsInt();

// 2. 计算总和与平均值
int sum = 0;
for (int num : arr) {
    sum += num;
}
double avg = (double) sum / arr.length;

// 使用 Stream
int sum2 = Arrays.stream(arr).sum();
double avg2 = Arrays.stream(arr).average().getAsDouble();

// 3. 反转数组
int[] original = {1, 2, 3, 4, 5};
int[] reversed = new int[original.length];
for (int i = 0; i < original.length; i++) {
    reversed[i] = original[original.length - 1 - i];
}

// 4. 判断数组是否包含某元素
boolean contains = false;
int target = 3;
for (int num : arr) {
    if (num == target) {
        contains = true;
        break;
    }
}

// 使用 Stream
boolean hasValue = Arrays.stream(arr).anyMatch(n -> n == target);

类型转换

自动类型转换

int i = 100;
double d = i;  // int 自动转为 double
System.out.println(d);  // 100.0

强制类型转换

double d = 3.14;
int i = (int) d;  // 强制转换，丢失小数部分
System.out.println(i);  // 3

运算符

算术运算符

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  - 取余

注意：整数除法结果也是整数

System.out.println(10 / 3);  // 3（不是 3.333...）
System.out.println(10.0 / 3); // 3.333...

赋值运算符

int a = 10;
a += 5;   // a = 15
a -= 3;   // a = 12
a *= 2;   // a = 24
a /= 4;   // a = 6
a %= 5;   // a = 1

比较运算符

System.out.println(5 == 5);    // true
System.out.println(5 != 3);    // true
System.out.println(5 > 3);     // true
System.out.println(5 < 3);     // false
System.out.println(5 >= 5);    // true
System.out.println(5 <= 3);    // false

逻辑运算符

boolean a = true, b = false;

System.out.println(a && b);  // false - 逻辑与
System.out.println(a || b);  // true  - 逻辑或
System.out.println(!a);      // false - 逻辑非

三元运算符

int age = 20;
String status = age >= 18 ? "成年" : "未成年";
System.out.println(status);  // 成年

运算符优先级

如果不确定优先级，可以使用括号来明确：

// 不使用括号
int result = 2 + 3 * 4;    // 14

// 使用括号
result = (2 + 3) * 4;      // 20

优先级从高到低：

1. () 括号
2. * / % 乘除取余
3. + - 加减
4. > < >= <= 比较
5. == != 等于不等于
6. && 逻辑与
7. || 逻辑或
8. ? : 三元运算符

注释

// 单行注释

/*
 * 多行注释
 * 可以跨越多行
 */

/**
 * 文档注释
 * 用于生成 API 文档
 */
public class Main {
    
}

输入和输出

输出

System.out.print("你好");   // 不换行
System.out.println("你好"); // 换行

// 格式化输出
String name = "张三";
int age = 20;
System.out.printf("姓名：%s，年龄：%d%n", name, age);

输入

import java.util.Scanner;

public class InputDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        System.out.print("请输入姓名：");
        String name = scanner.nextLine();
        
        System.out.print("请输入年龄：");
        int age = scanner.nextInt();
        
        System.out.println("你好，" + name + "，你" + age + "岁");
        
        scanner.close();
    }
}

小结

本章我们学习了：

1. 第一个 Java 程序的结构
2. 变量的声明和使用
3. 基本数据类型（整数、浮点数、字符、布尔）
4. 引用数据类型（字符串）
5. 类型转换
6. 各种运算符
7. 运算符优先级
8. 注释的使用
9. 输入输出操作

练习

1. 创建一个程序，声明不同类型的变量并打印
2. 实现两个数的加减乘除运算
3. 编写一个程序，输入你的名字和年龄并打印问候语
4. 判断一个数是奇数还是偶数
5. 实现两个数的大小比较，返回较大的数