System.out.println("5+5=" + 5 + 5);    // 5+5=55（先拼接）
System.out.println("5+5=" + (5 + 5));  // 5+5=10（括号优先）
System.out.println(1 + 99 + "年");      // 100年（数字先加）

if (条件) {
    // 条件为 true
} else if (条件2) {
    // ...
} else {
    // 以上都不满足
}
// if 只有一行且不是定义变量，可省略 {}

switch (light) {
    case 1 -> System.out.println("红灯停");
    case 2 -> System.out.println("绿灯行");
    default -> System.out.println("故障");
}

import java.util.Scanner;
Scanner sc = new Scanner(System.in);
int num     = sc.nextInt();      // 读整数
double d    = sc.nextDouble();   // 读小数
String word = sc.next();         // 读单词（遇空白停止）
String line = sc.nextLine();     // 读整行

import java.util.Random;
Random r = new Random();
int n1 = r.nextInt();        // int 范围内的随机数
int n2 = r.nextInt(100);     // [0, 100) → [0, 99]
int n3 = r.nextInt(100) + 1; // [1, 100]
int n4 = r.nextInt(min, max); // [min, max)  JDK17+

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

// 增强 for（只读，不能修改元素，不能用索引）
for (int num : arr) { System.out.println(num); }

// 求最大值
int max = arr[0];
for (int i = 1; i < arr.length; i++) { if (arr[i] > max) max = arr[i]; }

// 选择排序（升序）
for (int i = 0; i < arr.length - 1; i++) {
    for (int j = i + 1; j < arr.length; j++) {
        if (arr[i] > arr[j]) { int t = arr[i]; arr[i] = arr[j]; arr[j] = t; }
    }
}

// 冒泡排序（升序）
for (int i = 0; i < arr.length - 1; i++) {
    for (int j = 0; j < arr.length - i - 1; j++) {
        if (arr[j] > arr[j+1]) { int t = arr[j]; arr[j] = arr[j+1]; arr[j+1] = t; }
    }
}

// 二分查找（要求已排序）
int min = 0, max = arr.length - 1;
while (min <= max) {
    int mid = (min + max) / 2;
    if      (target > arr[mid]) min = mid + 1;
    else if (target < arr[mid]) max = mid - 1;
    else { System.out.println("找到，索引：" + mid); break; }
}

public static 返回值类型 方法名(参数类型 参数名, ...) {
    // 方法体
    return 返回值; // void 方法可省略
}

// 基本类型：值传递，互不影响
static void change(int a) { a = 100; }  // 外部 a 不变

// 引用类型：地址传递，修改元素会影响原数组
static void fill(int[] arr) { arr[0] = 999; } // 外部数组元素被修改

public static int    sum(int a, int b)          { return a + b; }
public static int    sum(int a, int b, int c)   { return a + b + c; }
public static double sum(double a, double b)    { return a + b; }
// 三个 sum 互为重载关系

public static int sum(int... nums) {
    int total = 0;
    for (int n : nums) total += n;
    return total;
}
sum(1, 2, 3);     // 传参数列表
sum(new int[]{1, 2}); // 传数组
sum();            // 不传参

// 打印 3行5列 *
for (int i = 1; i <= 3; i++) {
    for (int j = 1; j <= 5; j++) System.out.print("*");
    System.out.println();
}

// 递归求 1~n 的和
public static int sum(int n) {
    if (n == 1) return 1;       // 出口
    return n + sum(n - 1);      // 规律：sum(n) = n + sum(n-1)
}

public class Student {
    // 成员变量（封装：private）
    private String name;
    private int age;

    // 构造方法
    public Student() { }                          // 空参
    public Student(String name, int age) {         // 满参
        this.name = name;
        this.age = age;
    }

    // getter / setter
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

public class 类名 {
    private 数据类型 属性名;    // 所有成员变量 private

    public 类名() { }           // 空参构造（必须有）

    public 类名(参数...) {       // 满参构造
        this.属性 = 参数;
    }

    // 每个属性提供 getter + setter
    public 数据类型 get属性名() { return 属性名; }
    public void set属性名(数据类型 属性名) { this.属性名 = 属性名; }
}

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1 == s2);      // true（同一常量池对象）
System.out.println(s1 == s3);      // false（s3是堆中新对象）
System.out.println(s1.equals(s3)); // true（内容相同）

// 常用场景示例
String tel = "13812341234";
String start = tel.substring(0, 3);   // "138"
String end   = tel.substring(7);      // "1234"
System.out.println(start + "****" + end); // 138****1234

// 字符串遍历
String s = "Hello";
for (int i = 0; i < s.length(); i++) {
    System.out.print(s.charAt(i) + " "); // H e l l o
}

// 按逗号分割
String[] arr = "张三,23".split(",");
System.out.println(arr[0]); // 张三
System.out.println(arr[1]); // 23

// 链式调用
String result = new StringBuilder()
    .append("Hello")
    .append(" ")
    .append("World")
    .reverse()
    .toString();
System.out.println(result); // dlroW olleH

//String 转换为 StringBuilder
String s = "hello";
StringBuilder sb = new StringBuilder(s);
//StringBuilder 转换为 String
StringBuilder sb = new StringBuilder();
sb.append("hello");
String s = sb.toString();

// 字符串反转（经典用法）
public static String reverse(String str) {
    return new StringBuilder(str).reverse().toString();
}

// 数组拼接为指定格式字符串
public static String arrayToString(int[] arr) {
    StringBuilder sb = new StringBuilder("[");
    for (int i = 0; i < arr.length; i++) {
        sb.append(arr[i]);
        if (i < arr.length - 1) sb.append(", ");
    }
    return sb.append("]").toString();
}
// arrayToString(new int[]{1,2,3}) → "[1, 2, 3]"

// 只有分隔符
StringJoiner sj1 = new StringJoiner(", ");
sj1.add("Java").add("Python").add("C++");
System.out.println(sj1); // Java, Python, C++

// 带前缀和后缀
StringJoiner sj2 = new StringJoiner(", ", "[", "]");
sj2.add("Apple").add("Banana").add("Orange");
System.out.println(sj2); // [Apple, Banana, Orange]

// 设置空值默认显示
StringJoiner sj3 = new StringJoiner(", ", "{", "}");
sj3.setEmptyValue("{}");
System.out.println(sj3); // {}（没有添加任何元素）

class Fu { int num = 10; }
class Zi extends Fu {
    int num = 20;
    public void show() {
        int num = 30;
        System.out.println(num);       // 30（局部变量）
        System.out.println(this.num);  // 20（子类成员变量）
        System.out.println(super.num); // 10（父类成员变量）
    }
}

class Fu {
    int num;
    public Fu() { System.out.println("父空参"); }
    public Fu(int num) { this.num = num; System.out.println("父有参"); }
}
class Zi extends Fu {
    public Zi() {
        super();            // 可省略，JVM 自动添加
        System.out.println("子空参");
    }
    public Zi(int num) {
        super(num);         // ⭐手动调用父类带参构造
        System.out.println("子有参");
    }
}
// new Zi()    → 父空参 → 子空参
// new Zi(100) → 父有参 → 子有参


public class Employee {
    
    private String name;//姓名
    private int age;//年龄
    private int salary;//薪资

    public Employee() {}

    public Employee(String name, int age, int salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public void work() {
       	System.out.println("员工: " + name + ", 正在努力的工作~");
    }

    ...      
}

public class Teacher extends Employee {
    
    public Teacher() {
        //super();
    }

    public Teacher(String name, int age, int salary) {
        super(name, age, salary);// ⭐手动调用父类带参构造
    }
    
    @Override
    public void work() {
        System.out.println("讲师: " + getName() + ", 正在努力的讲解面向对象(OOP)编程~");
    }
}

class Fu {
    private void show() { }    // 子类无法重写
    void method() { }          // 默认权限
}
class Zi extends Fu {
    // @Override private void show() { } // ❌ 不能重写私有方法
    // @Override private void method() { } // ❌ 权限降低，报错
    @Override
    public void method() { }   // ✅ 权限提升（默认→public），合法
}

public abstract class Animal {
    private String name;
    // 抽象方法：所有动物都会吃，但吃什么不同
    public abstract void eat();
    // 普通方法：所有动物的行为相同
    public void breath() { System.out.println("呼吸"); }
    // 有构造方法，供子类初始化
    public Animal(String name) { this.name = name; }
}

public class Dog extends Animal {
    public Dog(String name) { super(name); }
    @Override
    public void eat() { System.out.println(getName() + "吃骨头"); }
}
// Animal a = new Animal(); // ❌ 不能实例化
Dog d = new Dog("旺财");    // ✅ 子类可以实例化,抽象类不能创建对象,但子类继承可以

public abstract class WritingTemplate {
    // final 防止子类改变模板结构
    public final void write() {
        System.out.println("开头：我的爸爸");
        content();           // 调用抽象方法（变化的部分）
        System.out.println("结尾：这就是我的爸爸！");
    }
    public abstract void content(); // 子类各自实现中间内容
}

public class Tom extends WritingTemplate {
    @Override
    public void content() {
        System.out.println("那是一个秋天，爸爸骑车接我放学……");
    }
}
// Tom tom = new Tom(); tom.write(); → 开头 + 具体内容 + 结尾

// final 修饰引用类型：地址不变，内容可变
final int[] arr = {10, 20, 30};
// arr = new int[]{1, 2, 3};  // ❌ 地址不能改变
arr[0] = 100;                  // ✅ 内容可以改变

// final 成员变量：必须在构造方法中赋值
class MyClass {
    final int num;      // 定义时未赋值
    final int num2 = 20; // 定义时赋值
    public MyClass() {
        num = 10;       // ✅ 在构造方法中赋值（必须）
        // num2 = 200;  // ❌ num2 已赋值，不能再改
    }
}

// final 修饰类：不能被继承
public final class StringLike { }
// class Sub extends StringLike { } // ❌ 报错

// final 修饰方法：不能被重写
public class Fu {
    public final void show() { }
}
public class Zi extends Fu {
    // @Override public void show() { } // ❌ 报错
}

@Override
public boolean equals(Object o) {
    // 第1步：比地址（自己和自己比，一定相等）
    if (this == o) return true;
    // 第2步：比类型（null 或不同类，一定不相等）
    if (o == null || getClass() != o.getClass()) return false;
    // 第3步：比内容（强转后逐属性比较）
    Student student = (Student) o;
    if (age != student.age) return false;
    return Objects.equals(name, student.name); // Objects.equals 安全处理 null
}

@Override
public int hashCode() {
    int result = name != null ? name.hashCode() : 0;
    result = 31 * result + age;  // 31 是质数，散列效果好
    return result;
}

public class Student {
    static String room;      // 类变量：教室（共享）
    String name;             // 实例变量：姓名（各自独有）

    // 类方法：可直接用类名调用
    public static void printRoom() {
        System.out.println("教室：" + room);
        // System.out.println(name); // ❌ 静态方法不能访问实例变量
    }
    // 实例方法：需要对象调用
    public void printName() {
        System.out.println(name + " 在 " + room); // ✅ 可访问静态变量
    }
}

Student.room = "B101";        // 类名调用静态变量（推荐）
Student.printRoom();          // 类名调用静态方法（推荐）

// 类实现多接口 + 继承：同时是学生、司机、歌手
class A extends Student implements Driver, Singer {
    @Override public void drive() { }
    @Override public void sing()  { }
}

public static void show() {
}

public interface A {   //接口中调用方法按使用默认default
    public default void show(){
        System.out.println("a接口的show方法...");
    }
    public static void show4(){
        System.out.println("a接口的show4方法...");
    }
}

public interface B {
    public default void show(){
        System.out.println("B接口的show方法...");
    }
    public static void show4(){
        System.out.println("B接口的show4方法...");
    }
}

// 接口静态方法只能通过接口名调用
A.show4();   // ❌ 编译错误
A.show4(); // ✅

// 多个接口同名默认方法：必须重写，并可指定调用哪个接口的实现
@Override
public void show() {
    A.super.show(); // 指定调用接口 A 的默认方法
    // B.super.show();
}

class Fu { int num = 10; public void method() { System.out.println("Fu"); } }
class Zi extends Fu { int num = 20; @Override public void method() { System.out.println("Zi"); } }

Fu f = new Zi();
System.out.println(f.num); // 10（变量：编译运行都看父类）
f.method();                // Zi（方法：运行看子类重写）

Animal a = new Dog();   // 向上转型（自动）
a.eat();                // 调用 Dog 重写的 eat()

// 需要调用 Dog 特有的 watchHome()，向下转型
if (a instanceof Dog) { // 先用 instanceof 判断，避免 ClassCastException
    Dog dog = (Dog) a;  // 向下转型
    dog.watchHome();
}

// 格式
new 父类/接口() {
    @Override
    重写的方法() { ... }
};

// 示例1：直接调用（只能调用一次）
new Animal() {
    @Override public void eat() { System.out.println("吃东西"); }
}.eat();

// 示例2：多态方式保存引用（可调用多次，但不能调用匿名类特有方法）
Animal a = new Animal() {
    @Override public void eat() { System.out.println("吃东西"); }
    public void special() { } // 特有方法，通过 a 调用不到
};
a.eat();

// 示例3：直接作为参数传递（最常见用法）
Arrays.sort(arr, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length(); // 按长度升序
    }
});

public class MyUtils {
    private MyUtils() { }  // 禁止实例化

    public static String createCode(int n) {
        String data = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        Random r = new Random();
        StringBuilder code = new StringBuilder();
        for (int i = 0; i < n; i++) {
            code.append(data.charAt(r.nextInt(data.length())));
        }
        return code.toString();
    }
}
// 使用：MyUtils.createCode(6)

int[] arr = {1, 4, 7, 2, 5, 8, 3};
System.out.println(Arrays.toString(arr));     // [1, 4, 7, 2, 5, 8, 3]
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));     // [1, 2, 3, 4, 5, 7, 8]
System.out.println(Arrays.binarySearch(arr, 5));  // 4
int[] copy = Arrays.copyOf(arr, 3);
System.out.println(Arrays.toString(copy));    // [1, 2, 3]
int[] range = Arrays.copyOfRange(arr, 2, 5);
System.out.println(Arrays.toString(range));   // [3, 4, 5]

String s = null;
// s.toString();                          // ❌ 空指针异常
System.out.println(Objects.toString(s));           // "null"
System.out.println(Objects.toString(s, "默认值")); // "默认值"
System.out.println(Objects.equals(s, "hello"));   // false（不报空指针）

@Test
public void testGetIndex() {
    int[] arr = {3, 6, 9};
    int index = getIndex(arr, 6);
    // 参数：提示信息, 期望值, 实际值
    Assert.assertEquals("逻辑有误", 1, index);
}

public enum Light {
    // 枚举对象（调用有参构造）
    RED("红灯", "停"),
    GREEN("绿灯", "行"),
    YELLOW("黄灯", "等");   // 后面有字段时必须加分号

    private final String color;
    private final String info;

    // 构造方法必须 private
    private Light(String color, String info) {
        this.color = color;
        this.info  = info;
    }

    // 只提供 get，不提供 set（枚举对象不可修改）
    public String getColor() { return color; }
    public String getInfo()  { return info; }
}

// 遍历所有枚举项
for (Light v : Light.values()) {
    System.out.println((v.ordinal()+1) + ": "
        + v.name() + " → " + v.getColor() + " → " + v.getInfo());
}

// 配合 switch 使用（枚举的经典场景）
public static void handle(Light light) {
    switch (light) {
        case RED:    System.out.println("请停车"); break;
        case GREEN:  System.out.println("请通行"); break;
        case YELLOW: System.out.println("请等待"); break;
    }
}

// throw：方法内，抛具体对象
public static int getValue(int[] arr, int index) throws Exception {
    if (arr == null)
        throw new Exception("数组不能为 null");
    if (index < 0 || index >= arr.length)
        throw new ArrayIndexOutOfBoundsException("非法索引：" + index);
    return arr[index];
}

// throws：方法声明上，列出异常类型
public static void abc(int a) throws NullPointerException, Exception {
    if (a < 0) throw new NullPointerException("a 不能为负数");
    throw new Exception("其他异常");
}

public static void readFile(String path) throws FileNotFoundException {
    throw new FileNotFoundException("文件不存在：" + path);
}

try {
    // 可能产生异常的代码
    getValue(arr, 5);
} catch (ArrayIndexOutOfBoundsException e) {
    // 子类异常放前面，父类放后面（否则父类 catch 会拦截所有）
    System.out.println("索引越界：" + e.getMessage());
} catch (Exception e) {
    // 兜底：捕获其他所有异常
    e.printStackTrace();
} finally {
    // 无论是否异常都会执行（常用于关闭 IO 流、数据库连接等资源）
    System.out.println("资源已释放");
}

class Fu {
    public void method() { }           // 父类无 throws
}
class Zi extends Fu {
    @Override
    public void method() {             // ❌ 不能加 throws Exception
        try {
            throw new Exception("问题");
        } catch (Exception e) {        // ✅ 只能内部 try-catch
            e.printStackTrace();
        }
    }
}

// 自定义编译时异常
public class UserNameRegisterException extends Exception {
    public UserNameRegisterException() { }
    public UserNameRegisterException(String message) {
        super(message); // 传给父类，getMessage() 可取到
    }
}

// 使用
public static void register(String name) throws UserNameRegisterException {
    if ("admin".equals(name))
        throw new UserNameRegisterException("用户名 [" + name + "] 已被注册");
    System.out.println("注册成功：" + name);
}

// 调用处
try {
    register("admin");
} catch (UserNameRegisterException e) {
    e.printStackTrace();
}

// 手动装箱（了解，JDK9 后构造方法已过时）
Integer i1 = Integer.valueOf(123);

// 自动装箱（推荐）
Integer i2 = 456;

// 自动拆箱
int i3 = i2;

Integer a = new Integer(100);
Integer b = new Integer(100);
System.out.println(a == b);           // false（两个不同对象）

Integer c = Integer.valueOf(100);     // 走缓存
Integer d = Integer.valueOf(100);
System.out.println(c == d);           // true（同一个缓存对象）

Integer e = Integer.valueOf(200);     // 超出范围，新建对象
Integer f = Integer.valueOf(200);
System.out.println(e == f);           // false

// 综合案例：字符串数字序列排序
String s = "22,1,555,128,44,77,99,25,6,888,111";
String[] arr = s.split(",");
int[] nums = new int[arr.length];
for (int i = 0; i < arr.length; i++) nums[i] = Integer.parseInt(arr[i]);
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));

Date d = new Date();                       // 当前时间
long time = d.getTime();                   // 获取毫秒值
Date d2 = new Date(time + 2 * 1000);      // 2秒后的时间

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

// 格式化：Date → String
String str = sdf.format(new Date()); // "2026-03-24 15:30:05"

// 解析：String → Date（格式必须一致）
Date d = sdf.parse("2026-03-24 15:30:05");

// 实用案例：判断秒杀是否在活动时间内
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-M-d H:m:s");
long start = sdf2.parse("2026-3-1 0:0:0").getTime();
long end   = sdf2.parse("2026-3-1 0:10:0").getTime();
long user  = sdf2.parse("2026-3-1 0:3:47").getTime();
System.out.println(user >= start && user <= end ? "秒杀成功" : "秒杀失败");

Calendar c = Calendar.getInstance();
int year  = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1; // ⚠️ 月份要 +1
int day   = c.get(Calendar.DAY_OF_MONTH);

c.add(Calendar.DAY_OF_YEAR, 100);  // 100天后
c.add(Calendar.HOUR, -12);          // 12小时前

LocalDateTime ldt = LocalDateTime.now();

// 获取信息
System.out.println(ldt.getYear() + "年" + ldt.getMonthValue() + "月");

// 不可变：每次操作返回新对象，原对象不变
LocalDateTime next = ldt.plusDays(10).withHour(8);

// 比较
LocalDateTime target = LocalDateTime.of(2029, 12, 12, 0, 0, 0);
System.out.println(target.isAfter(ldt)); // true