Java核心 - 基础语法

// 单行注释：从 // 开始到行尾

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

/**
 * 文档注释：
 * 用于生成 API 文档
 * @param args 命令行参数
 * @return 无返回值
 */

// 合法的标识符
int age;
String userName;
double _value;
int $count;

// 非法的标识符
// int 2name;    // 不能以数字开头
// int class;    // 不能使用关键字
// int my-name;  // 不能包含连字符

byte b = 100;
short s = 10000;
int i = 100000;
long l = 10000000000L;    // 需要 L 后缀

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

char c = 'A';
boolean flag = true;

String str = "Hello";           // 字符串
int[] arr = {1, 2, 3};          // 数组
Object obj = new Object();      // 对象
List<String> list = new ArrayList<>();  // 接口

// 自动装箱：基本类型 → 包装类
Integer num = 100;  // 实际调用 Integer.valueOf(100)

// 自动拆箱：包装类 → 基本类型
int n = num;        // 实际调用 num.intValue()

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true（使用缓存）

Integer c = 128;
Integer d = 128;
System.out.println(c == d);      // false（新建对象）
System.out.println(c.equals(d)); // true（值相等）

// 自动类型转换（小 → 大，隐式）
int i = 100;
long l = i;      // int → long
double d = l;    // long → double

// 强制类型转换（大 → 小，显式）
double d2 = 3.99;
int i2 = (int) d2;  // 结果为 3，直接截断小数

// 表达式中的类型提升
byte b1 = 10;
byte b2 = 20;
// byte b3 = b1 + b2;  // 错误！运算结果为 int
int b3 = b1 + b2;      // 正确

int a = 5, b = 3;
System.out.println(a / b);   // 1（整数除法）
System.out.println(a % b);   // 2

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

int x = 5;
// 短路与：第一个为 false，不计算第二个
boolean result = (x > 10) && (++x > 5);  // x 仍为 5

int a = 10;     // 基本赋值
a += 5;         // a = a + 5
a -= 3;         // a = a - 3
a *= 2;         // a = a * 2
a /= 4;         // a = a / 4
a %= 3;         // a = a % 3

int a = 10, b = 20;
int max = (a > b) ? a : b;  // 如果 a > b 返回 a，否则返回 b

// 基本 if
if (条件) {
    // 条件为 true 时执行
}

// if-else
if (条件) {
    // 条件为 true 时执行
} else {
    // 条件为 false 时执行
}

// if-else if-else
if (条件1) {
    // 条件1 为 true
} else if (条件2) {
    // 条件2 为 true
} else if (条件3) {
    // 条件3 为 true
} else {
    // 以上条件都不满足
}

// 传统 switch
switch (表达式) {
    case 值1:
        // 匹配值1时执行
        break;
    case 值2:
        // 匹配值2时执行
        break;
    default:
        // 都不匹配时执行
}

// Java 12+ switch 表达式
String day = "MONDAY";
String type = switch (day) {
    case "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY" -> "工作日";
    case "SATURDAY", "SUNDAY" -> "周末";
    default -> "未知";
};

// 基本 for 循环
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

// 增强 for 循环（foreach）
int[] arr = {1, 2, 3, 4, 5};
for (int num : arr) {
    System.out.println(num);
}

// 嵌套循环
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.println(i + ", " + j);
    }
}

// while 循环：先判断后执行
int i = 0;
while (i < 5) {
    System.out.println(i);
    i++;
}

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

// break：退出当前循环
for (int i = 0; i < 10; i++) {
    if (i == 5) break;    // i=5 时退出循环
    System.out.println(i);
}

// continue：跳过本次循环
for (int i = 0; i < 10; i++) {
    if (i == 5) continue; // 跳过 i=5
    System.out.println(i);
}

// 带标签的 break/continue（跳出外层循环）
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (j == 1) break outer;  // 直接跳出外层循环
        System.out.println(i + ", " + j);
    }
}

// 声明
int[] arr1;        // 推荐写法
int arr2[];        // C 风格，不推荐

// 静态初始化
int[] arr3 = {1, 2, 3, 4, 5};
int[] arr4 = new int[]{1, 2, 3};

// 动态初始化
int[] arr5 = new int[5];   // 默认值为 0
String[] arr6 = new String[3];  // 默认值为 null

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

// 访问元素（下标从 0 开始）
System.out.println(arr[0]);  // 10
arr[1] = 25;                 // 修改元素

// 数组长度
System.out.println(arr.length);  // 5

// 遍历数组
for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

// 增强 for 循环
for (int num : arr) {
    System.out.println(num);
}

// 二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

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

// 遍历
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.println(matrix[i][j]);
    }
}

// 不规则数组
int[][] irregular = new int[3][];
irregular[0] = new int[2];
irregular[1] = new int[3];
irregular[2] = new int[4];

import java.util.Arrays;

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

// 排序
Arrays.sort(arr);

// 二分查找（需要先排序）
int index = Arrays.binarySearch(arr, 5);

// 填充
Arrays.fill(arr, 0);

// 复制
int[] copy = Arrays.copyOf(arr, 10);

// 转字符串
System.out.println(Arrays.toString(arr));

// 比较
boolean equal = Arrays.equals(arr1, arr2);

修饰符 返回类型 方法名(参数列表) {
    // 方法体
    return 返回值;  // void 方法可省略
}

// 无参无返回值
public void sayHello() {
    System.out.println("Hello!");
}

// 有参有返回值
public int add(int a, int b) {
    return a + b;
}

// 静态方法
public static double square(double num) {
    return num * num;
}

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public double add(double a, double b) {
        return a + b;
    }
    
    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

// 可变参数必须是最后一个参数
public int sum(int... nums) {
    int total = 0;
    for (int num : nums) {
        total += num;
    }
    return total;
}

// 调用
sum(1, 2, 3);
sum(1, 2, 3, 4, 5);

// 基本类型：传递的是值的副本
public void change(int num) {
    num = 100;  // 不影响外部变量
}

// 引用类型：传递的是引用的副本（指向同一对象）
public void change(int[] arr) {
    arr[0] = 100;  // 会修改数组内容
    arr = new int[]{1, 2, 3};  // 不影响外部引用
}