package com.example;

// 这是一个Car类，是所有具体汽车的“图纸”
class Car {
    // 字段(Fields)，描述汽车的状态
    String brand;
    String color;
    int speed;

    // 方法(Methods)，描述汽车的行为
    void startEngine() {
        System.out.println(brand + " 的引擎启动了！");
    }

    void accelerate() {
        speed += 10;
        System.out.println("当前车速: " + speed + " km/h");
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用 new 关键字，根据Car类的图纸，创建一个具体的Car对象
        Car myCar = new Car();
        
        // 为这个对象的字段赋值，赋予它独立的状态
        myCar.brand = "特斯拉";
        myCar.color = "红色";
        myCar.speed = 0;
        
        System.out.println("我有一辆" + myCar.color + "的" + myCar.brand);
        
        // 调用对象的行为
        myCar.startEngine();
        myCar.accelerate();

        System.out.println("--------------------");

        // 创建另一个独立的对象
        Car yourCar = new Car();
        yourCar.brand = "保时捷";
        yourCar.color = "白色";
        System.out.println("你有一辆" + yourCar.color + "的" + yourCar.brand);
        yourCar.startEngine();
    }
}

package com.example;

class Car {
    String brand;
    String color;

    // 1. 无参构造器
    public Car() {
        System.out.println("无参构造器被调用，创建了一辆默认汽车。");
        this.brand = "未知品牌";
        this.color = "黑色";
    }

    // 2. 带一个参数的构造器
    public Car(String brand) {
        System.out.println("带品牌参数的构造器被调用。");
        this.brand = brand;
        this.color = "白色"; // 默认颜色
    }

    // 3. 带两个参数的构造器 (重载)
    public Car(String brand, String color) {
        System.out.println("带品牌和颜色参数的构造器被调用。");
        this.brand = brand;
        this.color = color;
    }
    
    void printInfo() {
        System.out.println("这是一辆" + this.color + "的" + this.brand);
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用无参构造器
        Car defaultCar = new Car();
        defaultCar.printInfo();

        System.out.println("----------");

        // 使用带品牌参数的构造器
        Car bmw = new Car("宝马");
        bmw.printInfo();
    }
}

package com.example;

class Car {
    String brand;

    // 构造器的参数brand与成员变量brand同名
    public Car(String brand) {
        // this.brand 指的是当前对象的成员变量
        // brand 指的是传入的参数
        this.brand = brand; 
    }
}

package com.example;

class Car {
    String brand;
    String color;

    // 两个参数的构造器
    public Car(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    // 无参构造器通过 this(...) 调用了上面的构造器，为其提供了默认值
    public Car() {
        this("奥迪", "黑色"); // 调用本类中其他构造器，必须放在第一行
        System.out.println("无参构造器执行完毕");
    }
}

package com.example;

// 引入Serializable接口是JavaBean的一个推荐实践，用于对象持久化或网络传输
import java.io.Serializable;

// 1. 类是 public 的
public class Main implements Serializable {
    // 3. 字段是 private 的
    private String name;
    private int age;
    private boolean isStudent;

    // 2. public 的无参构造器
    public Main() {
    }

    // 4. public 的 getter 和 setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        // 可以在setter中加入验证逻辑
        if (name == null || name.isEmpty()) {
            throw new IllegalArgumentException("Name cannot be empty.");
        }
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("Invalid age.");
        }
        this.age = age;
    }
    
    // boolean类型的getter可以是 'is' 开头
    public boolean isStudent() {
        return isStudent;
    }

    public void setStudent(boolean student) {
        isStudent = student;
    }
}

// Animal是父类
class Animal {
    String name;
    public void eat() {
        System.out.println(name + " 正在吃东西...");
    }
}

// Dog是子类，使用extends继承Animal
class Dog extends Animal {
    public void bark() {
        System.out.println(name + " 正在汪汪叫！");
    }
}

package com.example;

class Parent {
    public final void coreAlgorithm() {
        System.out.println("这是核心算法，不许修改！");
    }
}

class Child extends Parent {
    // 下面的代码将导致编译错误
    // public void coreAlgorithm() { ... } 
}

package com.example;

// String类是final的，无法被继承
// class MyString extends String { ... } // 这行代码会导致编译错误

public final class SealedBox {
    // 这个类是最终的，不能被继承
}

package com.example;

public class Main {
    public static void main(String[] args) {
        System.out.println("--- 动态方法分派演示 ---");

        // 1. 编译看左边
        //    我们声明一个父类类型的引用变量。
        //    编译器此时只知道 'myPet' 是 Animal 类型，
        //    因此它只允许调用 Animal 类中定义的方法。
        Animal myPet;

        // 尝试调用 Dog 特有的方法，会在编译时报错：
        // myPet = new Dog(); // 如果先赋值，编译器仍然看 'Animal'
        // myPet.fetch();     // !!! 这行会编译失败 !!!
        // 原因：编译器不知道 myPet 具体指向什么，
        // 它只知道引用类型是 Animal，而 Animal 没有 fetch() 方法。

        // 2. 运行看右边
        //    创建了一个 Dog 对象，并让父类引用指向它。
        myPet = new Dog(); // myPet 的声明类型是 Animal，但实际指向的是一个 Dog 对象。

        // 调用 speak() 方法：
        // 在运行时，JVM会检查 myPet 指向的实际对象是什么类型。
        // 它发现对象是 Dog 类型的，并且 Dog 类重写了 speak() 方法。
        // 所以，JVM 会执行 Dog 类中的 speak() 方法。
        System.out.print("通过 Animal 引用调用 speak(): ");
        myPet.speak();

        // 如果 Dog 没有重写 speak()，则会执行 Animal 的 speak()。
        // 如果有其他子类如 Cat 没有重写 speak()，指向 Cat 对象时就会执行 Animal 的 speak()。

        System.out.println("--- 演示结束 ---");
    }
}

// 父类 (Parent Class)
class Animal {
    // 一个可以被子类重写的方法
    public void speak() {
        System.out.println("Animal makes a sound.");
    }

    // 一个子类特有的方法，父类没有定义
    public void fetch() {
        System.out.println("Animal is fetching.");
    }
}

// 子类 (Child Class)
class Dog extends Animal {
    // 重写父类的 speak() 方法
    @Override
    public void speak() {
        System.out.println("Dog barks.");
    }

    // Dog 类特有的方法，Animal 类没有
    public void fetch() { // 注意：这里 Dog 重写了 Animal 的 fetch，但本例重点是 speak
        System.out.println("Dog fetches the ball.");
    }
}

package com.example;

class Animal {
    public void makeSound() {
        System.out.println("动物发出声音...");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("汪汪！");
    }

    // Dog的特有方法
    public void wagTail() {
        System.out.println("狗狗在摇尾巴。");
    }
}


class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("喵喵~");
    }

    // Cat的特有方法
    public void scratchSofa() {
        System.out.println("猫在抓沙发！");
    }
}


public class Main {
    // 这个方法可以接收任何Animal的子类对象，体现了多态
    public static void petAction(Animal pet) {
        System.out.println("宠物开始行动...");
        pet.makeSound();// 动态分派：运行时调用的是具体子类的方法

        // 想要调用子类的特有方法，必须进行安全的向下转型
        // 传统写法
        if (pet instanceof Dog) {
            Dog dog = (Dog) pet;
            dog.wagTail();
        }

        // [Java 16+] 使用模式匹配的写法，更简洁安全
        if (pet instanceof Cat cat) {
            // 如果pet是Cat类型，会自动转换并赋值给新变量cat
            cat.scratchSofa();
        }

    }

    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        System.out.println("--- 操作狗对象 ---");
        petAction(myDog);
        System.out.println("\n--- 操作猫对象 ---");
        petAction(myCat);
    }
}

/**
 * 定义了一个“可飞行”的行为契约 (can-do contract)。
 * 任何类只要实现了这个接口，就意味着它具备了飞行的能力。
 */
public interface Flyable {
    // 接口中的方法默认是 public abstract 的，所以可以省略关键字。
    // 它只定义了“应该能飞”，但不关心“如何飞”。
    void fly();
}

// Bird是一个具体的类，它实现了Flyable接口。
public class Bird implements Flyable {
    private String name;

    public Bird(String name) {
        this.name = name;
    }

    @Override
    public void fly() {
        // 这是Bird类对fly()方法的具体实现
        System.out.println("小鸟 '" + name + "' 扇动翅膀，在空中飞翔。");
    }
}

// Airplane是另一个完全不相关的类，它也实现了Flyable接口。
public class Airplane implements Flyable {
    private String model;

    public Airplane(String model) {
        this.model = model;
    }

    @Override
    public void fly() {
        // 这是Airplane类对fly()方法的具体实现
        System.out.println("飞机 '" + model + "' 启动引擎，高速巡航。");
    }
}

// Superman是第三个不相关的类。
public class Superman implements Flyable {
    @Override
    public void fly() {
        // 这是Superman类对fly()方法的具体实现
        System.out.println("超人披风一甩，像一颗子弹一样飞向天空！");
    }
}

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

public class Main {
    public static void main(String[] args) {
        // 创建一个列表，它的类型是Flyable接口。
        // 这意味着任何实现了Flyable接口的对象都可以被放进去。
        List<Flyable> flyingThings = new ArrayList<>();

        // 1. 添加各种不同具体类型、但都“能飞”的对象
        flyingThings.add(new Bird("画眉"));
        flyingThings.add(new Airplane("波音747"));
        flyingThings.add(new Superman());
        // 如果未来有了一个新的“风筝”类也实现了Flyable，可以直接加进来，无需修改这里的代码。
        // flyingThings.add(new Kite());

        // 2. 统一处理所有能飞的对象
        // 遍历这个列表，调用每个对象的fly()方法
        for (Flyable thing : flyingThings) {
            // 这里发生了多态：
            // 编译时，编译器只知道thing是一个Flyable，并且它一定有fly()方法。
            // 运行时，JVM会根据thing的实际类型（Bird, Airplane, or Superman）
            // 来调用各自类中重写的那个具体fly()方法。
            thing.fly();
        }
    }
}

package com.example;

// 抽象类：饮品
abstract class Beverage {
    // 这是一个模板方法，它定义了算法的骨架，且不希望被子类修改
    public final void prepareRecipe() {
        boilWater();
        brew(); // <-- 变化的步骤，由子类实现
        pourInCup();
        addCondiments(); // <-- 变化的步骤，由子类实现
    }

    // 抽象方法，子类必须实现
    protected abstract void brew();
    protected abstract void addCondiments();

    // 具体方法，所有子类共用
    public void boilWater() {
        System.out.println("烧开水");
    }
    public void pourInCup() {
        System.out.println("倒入杯中");
    }
}

// 具体子类：咖啡
class Coffee extends Beverage {
    @Override
    protected void brew() {
        System.out.println("用沸水冲泡咖啡");
    }
    @Override
    protected void addCondiments() {
        System.out.println("加糖和牛奶");
    }
}

// 具体子类：茶
class Tea extends Beverage {
    @Override
    protected void brew() {
        System.out.println("用沸水浸泡茶叶");
    }
    @Override
    protected void addCondiments() {
        System.out.println("加柠檬");
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println("--- 制作咖啡 ---");
        Beverage myCoffee = new Coffee();
        myCoffee.prepareRecipe();

        System.out.println("\n--- 制作茶 ---");
        Beverage myTea = new Tea();
        myTea.prepareRecipe();
    }
}

package com.example;

import java.util.Objects;

class Person {
    private String idCard;
    private String name;

    public Person(String idCard, String name) {
        this.idCard = idCard;
        this.name = name;
    }

    // 正确的、健壮的equals方法实现模板
    @Override
    public boolean equals(Object obj) {
        // 1. 检查是否为同一个对象引用
        if (this == obj) return true;

        // 2. 检查obj是否为null，以及类型是否完全一致
        if (obj == null || getClass() != obj.getClass()) return false;

        // 3. 强制类型转换
        Person person = (Person) obj;

        // 4. 比较核心字段的内容是否相等
        return Objects.equals(idCard, person.idCard);
    }
}

public class Main {
    public static void main(String[] args) {
        Person p1 = new Person("12345", "张三");
        Person p2 = new Person("12345", "三·张"); // 姓名不同
        Person p3 = new Person("54321", "李四");

        System.out.println("p1.equals(p2): " + p1.equals(p2)); // true，因为idCard相同
        System.out.println("p1.equals(p3): " + p1.equals(p3)); // false，因为idCard不同
    }
}

package com.example;

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

class PersonWithoutHashCode {
    private String idCard;
    public PersonWithoutHashCode(String id) { this.idCard = id; }

    @Override
    public boolean equals(Object obj) { // 只重写了equals
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        return Objects.equals(idCard, ((PersonWithoutHashCode) obj).idCard);
    }
    // 未重写hashCode()!
}

public class Main {
    public static void main(String[] args) {
        Set<PersonWithoutHashCode> set = new HashSet<>();
        set.add(new PersonWithoutHashCode("123"));
        set.add(new PersonWithoutHashCode("123")); // 试图添加一个“相等”的对象

        // 因为hashCode不同，HashSet认为它们是两个不同的对象
        System.out.println("集合大小: " + set.size()); // 输出: 2，错误！本应是1

        // contains方法也无法正常工作
        System.out.println("集合是否包含身份证为123的人: " + 
            set.contains(new PersonWithoutHashCode("123"))); // 输出: false，错误！
    }
}

// 在Person类中添加
@Override
public String toString() {
    return "Person{idCard='" + idCard + "', name='" + name + "'}";
}
// 之后 System.out.println(personObject); 就会打印出格式化的内容。

package com.example;

// Address是可变对象
class Address implements Cloneable {
    public String city;
    public Address(String city) { this.city = city; }
    
    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class User implements Cloneable {
    public String name;
    public Address address; // 引用类型字段

    public User(String name, Address address) { this.name = name; this.address = address; }
    
    // 实现深拷贝
    @Override
    public Object clone() throws CloneNotSupportedException {
        // 1. 先进行浅拷贝，复制基本类型和引用地址
        User clonedUser = (User) super.clone();
        // 2. 对引用类型的字段，手动进行单独的克隆
        clonedUser.address = (Address) this.address.clone(); 
        return clonedUser;
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Address address = new Address("北京");
        User user1 = new User("张三", address);

        // 使用深拷贝克隆
        User user2 = (User) user1.clone(); 
        
        // 修改克隆对象的地址
        user2.address.city = "上海";

        // 验证原对象是否受影响
        System.out.println("原用户的城市: " + user1.address.city); // 输出：北京，未受影响
        System.out.println("克隆用户的城市: " + user2.address.city); // 输出：上海
    }
}

package com.example;

class User {
    // 静态变量，属于User类，用于计数，所有User对象共享此变量
    private static int userCounter = 0;
    
    // 实例变量，每个User对象独有一份
    private int userId;
    private String name;

    public User(String name) {
        // 每当构造器被调用（即创建一个新对象），静态计数器加1
        userCounter++;
        this.userId = userCounter; // 将当前的计数值赋给新用户的ID
        this.name = name;
        System.out.println("第 " + this.userId + " 个用户 '" + this.name + "' 已创建。");
    }

    public static int getTotalUsers() {
        return userCounter;
    }
}

public class Main {
    public static void main(String[] args) {
        new User("Alice");
        new User("Bob");
        new User("Charlie");
        
        // 可以通过类名直接访问静态成员
        System.out.println("总用户数: " + User.getTotalUsers());
    }
}

package com.example;

// 一个简单的数学工具类
final class MathUtils {
    // 构造器私有化，防止外部创建实例，因为所有方法都是静态的，无需对象
    private MathUtils() {}

    // 静态方法，计算两数之和
    public static int add(int a, int b) {
        return a + b;
    }
    
    // 静态方法，计算圆的面积
    public static double circleArea(double radius) {
        return Math.PI * radius * radius;
    }
}

public class Main {
    public static void main(String[] args) {
        // 直接通过类名调用静态方法，无需创建MathUtils对象
        int sum = MathUtils.add(15, 27);
        double area = MathUtils.circleArea(10.0);

        System.out.println("15 + 27 = " + sum);
        System.out.println("半径为10的圆面积: " + area);
    }
}

package com.example;

import java.util.HashMap;
import java.util.Map;

class ConfigLoader {
    // 定义一个静态Map用于存储配置
    public static final Map<String, String> CONFIG_MAP = new HashMap<>();

    // 静态代码块，在ConfigLoader类被加载时执行一次
    static {
        System.out.println("静态代码块执行：正在加载系统配置...");
        // 模拟从文件或数据库加载配置
        CONFIG_MAP.put("db.driver", "com.mysql.cj.jdbc.Driver");
        CONFIG_MAP.put("api.url", "https://api.example.com");
        CONFIG_MAP.put("default.timeout", "3000");
        System.out.println("配置加载完毕！");
    }
}

public class Main {
    public static void main(String[] args) {
        // 第一次访问ConfigLoader的静态成员时，会触发静态代码块的执行
        System.out.println("获取数据库驱动: " + ConfigLoader.CONFIG_MAP.get("db.driver"));
        
        System.out.println("---");
        
        // 第二次访问时，静态代码块不会再次执行
        System.out.println("获取API地址: " + ConfigLoader.CONFIG_MAP.get("api.url"));
    }
}

package com.example;

// 假设Computer是一个复杂的对象，有很多可选配置
class Computer {
    // 必需参数
    private final String cpu;
    private final String ram;
    // 可选参数
    private final String storage;
    private final String gpu;

    // 构造器是私有的，强制用户通过Builder来创建对象
    private Computer(Builder builder) {
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.storage = builder.storage;
        this.gpu = builder.gpu;
    }

    @Override
    public String toString() {
        return "Computer [CPU=" + cpu + ", RAM=" + ram + ", Storage=" + storage + ", GPU=" + gpu + "]";
    }

    // 静态内部类 Builder
    public static class Builder {
        private final String cpu; // 必需
        private final String ram; // 必需
        private String storage = "256GB SSD"; // 可选，提供默认值
        private String gpu = "Integrated"; // 可选，提供默认值

        public Builder(String cpu, String ram) {
            this.cpu = cpu;
            this.ram = ram;
        }

        public Builder storage(String storage) {
            this.storage = storage;
            return this; // 返回this以支持链式调用
        }

        public Builder gpu(String gpu) {
            this.gpu = gpu;
            return this;
        }

        public Computer build() {
            return new Computer(this);
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 使用Builder链式调用来创建复杂的Computer对象，代码清晰易读
        Computer gamingPC = new Computer.Builder("Intel i9", "32GB")
                .storage("2TB NVMe SSD")
                .gpu("NVIDIA RTX 4090")
                .build();

        Computer officePC = new Computer.Builder("Intel i5", "16GB").build();

        System.out.println("游戏电脑配置: " + gamingPC);
        System.out.println("办公电脑配置: " + officePC);
    }
}

package com.example;

class Car {
    private String brand;
    private int speed = 0; // 汽车的私有状态

    public Car(String brand) {
        this.brand = brand;
    }

    // 成员内部类 Engine
    class Engine {
        private int rpm = 0; // 引擎的私有状态

        public void start() {
            // 内部类可以直接访问外部类的私有字段 brand 和 speed
            System.out.println(brand + " 的引擎启动了！外部车速: " + speed);
            this.rpm = 800;
        }

        public void accelerate() {
            // 内部类可以直接修改外部类的状态
            speed += 20;
            this.rpm += 500;
            System.out.println("引擎转速: " + this.rpm + " RPM, 车速提升至: " + speed + " km/h");
        }
    }

    // 外部类的方法，用于获取并使用内部类对象
    public void startCar() {
        Engine engine = new Engine(); // 在外部类内部，可以直接创建内部类实例
        engine.start();
        engine.accelerate();
    }
}

public class Main {
    public static void main(String[] args) {
        // 1. 创建外部类实例
        Car myCar = new Car("法拉利");
        myCar.startCar();

        System.out.println("---");

        // 2. 在外部创建成员内部类实例（不常用，但语法上可行）
        // 必须通过一个外部类对象来创建
        Car.Engine anotherEngine = myCar.new Engine();
        anotherEngine.start();
    }
}

package com.example;

import lombok.Builder;
import lombok.Data;

// Computer是一个复杂的对象
@Data
@Builder
class Computer {
    private final String cpu;
    private final String ram;
    private final String gpu;
}

public class Main {
    public static void main(String[] args) {
        // 直接创建静态内部类实例，无需外部类对象
        // 使用 Lombok 生成的构建器链式调用方法设置属性
        Computer gamingPC = Computer.builder()
                .cpu("Intel i9")
                .ram("32GB")
                .gpu("NVIDIA RTX 4090")
                .build();
        System.out.println(gamingPC);
    }
}

package com.example;

class Outer {
    public void display() {
        final String message = "这是一个局部变量"; // 必须是final或事实final

        // 定义在display方法内的局部内部类
        class LocalInner {
            public void print() {
                // 可以访问外部类的成员，也可以访问方法内的final局部变量
                System.out.println(message);
            }
        }

        // 只能在方法内部创建和使用
        LocalInner local = new LocalInner();
        local.print();
    }
}

public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.display();
    }
}

package com.example;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class Main {
    public static void main(String[] args) {
        // 创建一个窗口和一个按钮
        JFrame frame = new JFrame("匿名内部类示例");
        JButton registerButton = new JButton("注册");

        // --- 核心代码：使用匿名内部类作为事件监听器 ---
        // addActionListener需要一个ActionListener接口的实例。
        // 我们在这里直接用“new ActionListener()”来定义并创建一个实现类。
        registerButton.addActionListener(new ActionListener() {
            // 这是对ActionListener接口中唯一方法 actionPerformed 的实现
            @Override
            public void actionPerformed(ActionEvent e) {
                // 这里是按钮被点击时要执行的逻辑
                System.out.println("注册按钮被点击！");
                JOptionPane.showMessageDialog(frame, "注册逻辑被触发！");
            }
        });
        // ---------------------------------------------

        // 将按钮添加到窗口并显示
        frame.add(registerButton);
        frame.setSize(300, 200);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }
}

package com.example;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

class Product {
    String name;
    double price;
    public Product(String name, double price) { this.name = name; this.price = price; }
    @Override
    public String toString() { return name + " (价格: " + price + ")"; }
}

public class Main {
    public static void main(String[] args) {
        List<Product> products = new ArrayList<>();
        products.add(new Product("笔记本电脑", 7999.0));
        products.add(new Product("机械键盘", 499.0));
        products.add(new Product("显示器", 1599.0));

        System.out.println("排序前: " + products);

        // --- 核心代码：使用匿名内部类实现一个临时的Comparator ---
        // List.sort()方法需要一个Comparator接口的实例来定义排序规则。
        products.sort(new Comparator<Product>() {
            // 实现compare方法，定义排序逻辑
            @Override
            public int compare(Product p1, Product p2) {
                // p2的价格减p1的价格，实现降序排序
                return Double.compare(p2.price, p1.price);
            }
        });
        // ----------------------------------------------------
        
        // 使用Lambda表达式简化
        products.sort((p1, p2 )-> Double.compare(p2.price, p1.price));
        

        System.out.println("按价格降序排序后: " + products);
    }
}

// 使用静态常量定义一周的星期
public class WeekConstants {
    public static final int MONDAY = 1;
    public static final int TUESDAY = 2;
    // ...
}

// 使用时
public void schedule(int day) {
    if (day == WeekConstants.MONDAY) {
        // ...
    }
}

// 定义一个简单的星期枚举
public enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

package com.example;

enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }

public class Main {
    public static String getFeeling(Day day) {
        // 使用switch表达式，代码简洁且安全
        return switch (day) {
            case MONDAY -> "有点不想上班...";
            case FRIDAY -> "耶！就快放假了！";
            case SATURDAY, SUNDAY -> "休息日，开心！";
            default -> "平常心，努力工作中...";
        };
    }

    public static void main(String[] args) {
        // 遍历所有枚举实例
        for (Day day : Day.values()) {
            System.out.println(day.name() + " (" + day.ordinal() + "): " + getFeeling(day));
        }
    }
}

package com.example;

import java.math.BigDecimal;
import java.math.RoundingMode;

enum PaymentType {
    // 1. 枚举实例必须在最前面声明，并可调用构造器
    ALI_PAY("支付宝", new BigDecimal("0.006")),
    WECHAT_PAY("微信支付", new BigDecimal("0.006")),
    CREDIT_CARD("信用卡", new BigDecimal("0.01")),
    DEBIT_CARD("储蓄卡", BigDecimal.ZERO); // 0费率

    // 2. 定义私有final字段
    private final String displayName; // 显示名称
    private final BigDecimal feeRate; // 费率

    // 3. 构造器必须是private的（或包私有）
    private PaymentType(String displayName, BigDecimal feeRate) {
        this.displayName = displayName;
        this.feeRate = feeRate;
    }

    // 4. 定义公共的getter方法
    public String getDisplayName() {
        return displayName;
    }

    public BigDecimal getFeeRate() {
        return feeRate;
    }

    // 5. 定义自己的业务方法
    public BigDecimal calculateFee(BigDecimal amount) {
        // 计算公式为：金额 * 费率
        return amount.multiply(this.feeRate).setScale(2, RoundingMode.HALF_UP);
    }

    @Override
    public String toString() {
        return this.displayName; // 重写toString，让打印更友好
    }
}

public class Main {
    public static void main(String[] args) {
        BigDecimal orderAmount = new BigDecimal("1000.00");

        PaymentType payment = PaymentType.CREDIT_CARD;

        System.out.println("选择的支付方式: " + payment);
        System.out.println("手续费率: " + payment.getFeeRate() + "%");
        System.out.println("订单金额 " + orderAmount + "元，手续费为: " + payment.calculateFee(orderAmount) + "元");
    }
}

package com.example;

// 1. 定义一个行为接口
interface Calculable {
    int calculate(int a, int b);
}

// 2. 让枚举实现这个接口
public enum Operation implements Calculable {
    // 3. 每个枚举实例都必须实现接口的方法，形成各自的策略
    PLUS("+") {
        @Override
        public int calculate(int a, int b) {
            return a + b;
        }
    },
    MINUS("-") {
        @Override
        public int calculate(int a, int b) {
            return a - b;
        }
    };
    // 也可以有自己的字段和构造器
    private final String symbol;
    private Operation(String symbol) { this.symbol = symbol; }
    
    @Override
    public String toString() { return symbol; }
}

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        // 直接调用枚举实例的方法，实现多态
        System.out.println(a + " " + Operation.PLUS + " " + b + " = " + Operation.PLUS.calculate(a, b));
        System.out.println(a + " " + Operation.MINUS + " " + b + " = " + Operation.MINUS.calculate(a, b));
    }
}