String s = "Hello";  // "Hello" 是一个String对象
LocalDate today = LocalDate.now();  // today 是LocalDate对象

// 预定义类：java.io.File
File file = new File("data.txt");  // 调用File(String path)构造器

// 等效于以下步骤：
// 1. JVM分配内存空间
// 2. 初始化字段默认值（引用=null, 数值=0, 布尔=false）
// 3. 执行构造器代码（本例中：将"data.txt"存入path字段）
// 4. 返回对象引用赋给file变量

// 正确：使用try-with-resources管理资源
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    // br对象在此块内有效
} // 自动调用br.close()释放资源

// 错误：未关闭资源
BufferedReader br = new BufferedReader(...);
// 忘记br.close() → 资源泄漏！

// 安全访问对象
if (scanner != null) {
    scanner.nextLine();
}

// Java 9+ 空安全方法
Objects.requireNonNull(scanner, "Scanner不能为null");

// 自定义类演示构造器链
public class Employee {
    private String name;
    private int id;
    
    // 主构造器
    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }
    
    // 辅助构造器（调用主构造器）
    public Employee(String name) {
        this(name, generateDefaultId());  // 调用主构造器
    }
    
    private static int generateDefaultId() { ... }
}

// 基本类型（值直接存储在变量中）
int x = 10;  
int y = x;   // 复制值（x=10, y=10）

// 对象类型（变量存储引用）
String s1 = "A";
String s2 = s1;   // 复制引用（s1和s2指向同一对象）
s2 = "B";         // s1仍为"A"，s2指向新对象"B"

// 正确处理链
try {
    Files.readString(Path.of("data.txt"));
} catch (NoSuchFileException e) {
    System.err.println("文件不存在");
} catch (IOException e) {
    System.err.println("IO错误: " + e.getMessage());
}

public class Employee {
    // 实例字段
    private String name;
    private double salary;
    private LocalDate hireDate;
    
    // -------------------- 构造器示例 --------------------
    
    // 1. 默认构造器（无参）
    public Employee() {
        // 提供默认值
        this.name = "Unknown";
        this.salary = 0.0;
        this.hireDate = LocalDate.now();
    }
    
    // 2. 带参数的构造器
    public Employee(String name, double salary) {
        // 使用this解决命名冲突
        this.name = name;
        this.salary = salary;
        this.hireDate = LocalDate.now();
    }
    
    // 3. 完整参数构造器
    public Employee(String name, double salary, LocalDate hireDate) {
        // 显式参数赋值给实例字段
        this.name = name;
        this.salary = salary;
        this.hireDate = hireDate;
    }
    
    // 4. 构造器链：调用其他构造器
    public Employee(String name) {
        // 调用双参数构造器
        this(name, 0.0); 
    }
    
    // 5. 构造器中的验证
    public Employee(String name, double salary) {
        // 验证参数有效性
        if (salary < 0) 
            throw new IllegalArgumentException("薪资不能为负数");
            
        this.name = Objects.requireNonNull(name, "姓名不能为null");
        this.salary = salary;
    }
}

// 创建对象的不同方式
Employee emp1 = new Employee(); // 使用默认构造器
Employee emp2 = new Employee("Alice", 75000); // 使用双参数构造器
Employee emp3 = new Employee("Bob", 85000, LocalDate.of(2020, 1, 15));

// 构造器链调用
Employee emp4 = new Employee("Charlie"); // 调用单参数构造器，再链式调用双参数构造器

public class NullSafety {
    // 1. 防御性检查
    public void processEmployee(Employee emp) {
        if (emp == null) {
            throw new IllegalArgumentException("员工对象不能为null");
        }
        // 安全操作
        System.out.println(emp.getName());
    }
    
    // 2. 使用 Objects.requireNonNull (Java 7+)
    public Employee createEmployee(String name, Double salary) {
        String validName = Objects.requireNonNull(name, "姓名不能为null");
        Double validSalary = Objects.requireNonNull(salary, "薪资不能为null");
        
        return new Employee(validName, validSalary);
    }
    
    // 3. 使用 Optional (Java 8+)
    public Optional<String> getManagerName(Employee emp) {
        return Optional.ofNullable(emp)
                       .map(Employee::getManager)
                       .map(Employee::getName);
    }
    
    // 4. 使用空对象模式
    public Employee getDepartmentHead(Department dept) {
        if (dept == null || dept.getHead() == null) {
            return new NullEmployee(); // 特殊空对象实现
        }
        return dept.getHead();
    }
    
    // 5. 使用注解 (@NonNull)
    public void updateSalary(@NonNull Employee emp, double newSalary) {
        // 编译时/运行时检查
        emp.setSalary(newSalary);
    }
}

public class Calculator {
    // 实例字段 - 属于隐式参数的一部分
    private double memory;
    
    // 方法：add 有两个参数
    // 隐式参数：this (Calculator实例)
    // 显式参数：a, b
    public double add(double a, double b) {
        // 访问隐式参数的状态
        this.memory = a + b;
        
        // 返回显式参数计算结果
        return a + b;
    }
    
    // 另一个方法：显示隐式参数的使用
    public double multiplyByMemory(double factor) {
        // this.memory 访问隐式参数的状态
        // factor 是显式参数
        return this.memory * factor;
    }
    
    // 静态方法示例 - 没有隐式参数
    public static double staticAdd(double a, double b) {
        // 错误：无法访问 this.memory
        // 只能使用显式参数 a 和 b
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        
        // 方法调用：
        // 隐式参数：calc (Calculator实例)
        // 显式参数：5.0 和 3.0
        double result = calc.add(5.0, 3.0); // 返回 8.0
        
        // 第二次调用：
        // 隐式参数：同一个calc实例（包含更新后的memory）
        // 显式参数：2.0
        double memoryResult = calc.multiplyByMemory(2.0); // 返回 16.0 (8.0 * 2.0)
        
        // 静态方法调用 - 没有隐式参数
        double staticResult = Calculator.staticAdd(4.0, 2.0); // 返回 6.0
    }
}

public class BankAccount {
    private final String accountNumber; // 不可变字段
    private double balance;
    private AccountType type;
    
    // 构造器：显式参数验证
    public BankAccount(String accountNumber, double initialBalance, AccountType type) {
        this.accountNumber = Objects.requireNonNull(accountNumber, "账号不能为null");
        
        if (initialBalance < 0) {
            throw new IllegalArgumentException("初始余额不能为负数");
        }
        this.balance = initialBalance;
        
        this.type = Objects.requireNonNull(type, "账户类型不能为null");
    }
    
    // 存款方法：显式参数验证
    public void deposit(double amount) {
        // 隐式参数：this (当前账户)
        // 显式参数：amount
        
        if (amount <= 0) {
            throw new IllegalArgumentException("存款金额必须为正数");
        }
        
        this.balance += amount;
    }
    
    // 取款方法：使用显式参数和隐式参数状态
    public boolean withdraw(double amount) {
        // 验证显式参数
        if (amount <= 0) {
            throw new IllegalArgumentException("取款金额必须为正数");
        }
        
        // 访问隐式参数状态
        if (amount > this.balance) {
            return false; // 余额不足
        }
        
        this.balance -= amount;
        return true;
    }
    
    // 转账方法：多个隐式参数
    public boolean transferTo(BankAccount target, double amount) {
        // 显式参数验证
        Objects.requireNonNull(target, "目标账户不能为null");
        
        // 使用当前对象状态（隐式参数）
        if (this.withdraw(amount)) {
            // 访问另一个对象的隐式参数
            target.deposit(amount);
            return true;
        }
        return false;
    }
    
    // 空对象模式应用
    public static BankAccount getNullAccount() {
        return new NullBankAccount();
    }
    
    // 静态工厂方法
    public static BankAccount createSavingsAccount(String accountNumber, double initialBalance) {
        return new BankAccount(accountNumber, initialBalance, AccountType.SAVINGS);
    }
    
    // 嵌套枚举
    public enum AccountType {
        CHECKING, SAVINGS, BUSINESS
    }
    
    // 空对象实现
    private static class NullBankAccount extends BankAccount {
        public NullBankAccount() {
            super("NULL-ACCOUNT", 0, AccountType.CHECKING);
        }
        
        @Override
        public void deposit(double amount) {
            // 空实现
        }
        
        @Override
        public boolean withdraw(double amount) {
            return false;
        }
    }
}

class MyClass {
    final int CONST_VAL = 10;         // 声明时初始化
    final int blankFinal;
    
    public MyClass() {
        blankFinal = 20;              // 构造方法初始化
    }
    
    {
        // 初始化块中初始化
        // blankFinal = 20; 
    }
}

void calculate() {
    final double PI;
    PI = 3.14159;      // 首次赋值
    // PI = 3.14;      // 错误！不可二次赋值
    
    final List<String> list = new ArrayList<>();
    list.add("OK");    // 合法：修改对象内容
    // list = new ArrayList<>();  // 错误！不可修改引用
}

final int age = 30;
// age = 40;  // 编译错误！基本类型值不可变

final List<String> names = new ArrayList<>();
names.add("Alice");    // 合法：修改对象内容
// names = new ArrayList<>();  // 编译错误！引用不可变

// Constants.java
public class Constants {
    public static final int MAX_SIZE = 100;      // 编译时常量
    public static final String PREFIX = "ID-";   // 编译时常量
    public static final long TIMESTAMP = System.currentTimeMillis(); // ❌ 非常量
}

// User.java
public class User {
    void print() {
        System.out.println(Constants.MAX_SIZE); // 编译后变为 System.out.println(100);
    }
}

// 不可变对象示例
public final class ImmutablePoint {
    private final int x;
    private final int y;
    
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    // 仅提供getter，无setter
}

public class Employee {
    // 实例字段 - 每个Employee对象都有自己的id和name
    private int id;
    private String name;
    
    // 静态字段 - 所有Employee对象共享一个计数器
    private static int nextId = 1;
    
    // 常量静态字段（通常大写命名）
    public static final double BASE_SALARY = 3000.0;

    public Employee(String name) {
        this.name = name;
        this.id = nextId;
        nextId++; // 修改共享静态字段
    }
}

// 访问常量静态字段
System.out.println("基本工资: " + Employee.BASE_SALARY);

// 创建对象
Employee alice = new Employee("Alice");
Employee bob = new Employee("Bob");

// 验证静态字段共享性
System.out.println(alice.id); // 输出1
System.out.println(bob.id);   // 输出2