// 這是一個 Student 物件
Student student1 = new Student("張小明", 20, "S001");
Student student2 = new Student("李小華", 19, "S002");

/**
 * 學生類別 - 定義學生物件的屬性和行為
 */
public class Student {
    // 屬性 (私有封裝)
    private String name;
    private int age;
    private String studentId;
    private List<Course> enrolledCourses;
    
    // 建構函式
    public Student(String name, int age, String studentId) {
        this.name = name;
        this.age = age;
        this.studentId = studentId;
        this.enrolledCourses = new ArrayList<>();
    }
    
    // 行為 (公開方法)
    public void enrollCourse(Course course) {
        enrolledCourses.add(course);
        System.out.println(name + " 已選修課程: " + course.getCourseName());
    }
    
    public void dropCourse(Course course) {
        enrolledCourses.remove(course);
        System.out.println(name + " 已退選課程: " + course.getCourseName());
    }
    
    // Getter 和 Setter 方法
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    // ... 其他 getter/setter
}

public class BankAccount {
    private double balance;  // 私有屬性，外部無法直接存取
    
    // 提供受控的存取方法
    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;  // 提款失敗
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public double getBalance() {
        return balance;  // 只提供讀取，不提供直接修改
    }
}

// 父類別 (超類別)
public abstract class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 共同行為
    public void eat() {
        System.out.println(name + " 正在吃東西");
    }
    
    // 抽象方法，子類別必須實作
    public abstract void makeSound();
}

// 子類別
public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age);  // 呼叫父類別建構函式
        this.breed = breed;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " 汪汪叫");
    }
    
    // 子類別特有的方法
    public void fetchBall() {
        System.out.println(name + " 去撿球");
    }
}

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + " 喵喵叫");
    }
    
    public void climbTree() {
        System.out.println(name + " 爬樹");
    }
}

public class AnimalDemo {
    public static void main(String[] args) {
        // 多型：同一個類型的引用指向不同的物件
        Animal[] animals = {
            new Dog("小黑", 3, "拉布拉多"),
            new Cat("小白", 2),
            new Dog("小黃", 1, "柴犬")
        };
        
        // 相同的方法呼叫，不同的執行結果
        for (Animal animal : animals) {
            animal.makeSound();  // 在執行時期決定呼叫哪個版本
            animal.eat();
        }
        
        // 輸出：
        // 小黑 汪汪叫
        // 小黑 正在吃東西
        // 小白 喵喵叫
        // 小白 正在吃東西
        // 小黃 汪汪叫
        // 小黃 正在吃東西
    }
    
    // 多型的另一個應用：方法參數
    public static void playWithAnimal(Animal animal) {
        animal.makeSound();
        // 不需要知道具體是什麼動物，只要是 Animal 類型都可以
    }
}

public abstract class Shape {
    protected String color;
    
    public Shape(String color) {
        this.color = color;
    }
    
    // 抽象方法，子類別必須實作
    public abstract double calculateArea();
    public abstract double calculatePerimeter();
    
    // 具體方法，子類別可以直接使用
    public void displayInfo() {
        System.out.println("顏色: " + color);
        System.out.println("面積: " + calculateArea());
        System.out.println("周長: " + calculatePerimeter());
    }
}

public class Rectangle extends Shape {
    private double width;
    private double height;
    
    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * (width + height);
    }
}

public interface Drawable {
    void draw();
    void setPosition(int x, int y);
}

public interface Resizable {
    void resize(double factor);
}

// 一個類別可以實作多個介面
public class Circle extends Shape implements Drawable, Resizable {
    private double radius;
    private int x, y;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
    
    @Override
    public void draw() {
        System.out.println("在座標 (" + x + ", " + y + ") 繪製圓形");
    }
    
    @Override
    public void setPosition(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    @Override
    public void resize(double factor) {
        this.radius *= factor;
    }
}

// 抽象基類
public abstract class Person {
    protected String name;
    protected String id;
    protected int age;
    
    public Person(String name, String id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }
    
    public abstract void displayInfo();
    
    // Getter 方法
    public String getName() { return name; }
    public String getId() { return id; }
    public int getAge() { return age; }
}

// 學生類別
public class Student extends Person {
    private String major;
    private List<Course> courses;
    private double gpa;
    
    public Student(String name, String id, int age, String major) {
        super(name, id, age);
        this.major = major;
        this.courses = new ArrayList<>();
        this.gpa = 0.0;
    }
    
    @Override
    public void displayInfo() {
        System.out.println("學生資訊:");
        System.out.println("姓名: " + name);
        System.out.println("學號: " + id);
        System.out.println("年齡: " + age);
        System.out.println("主修: " + major);
        System.out.println("GPA: " + gpa);
    }
    
    public void enrollCourse(Course course) {
        if (!courses.contains(course)) {
            courses.add(course);
            course.addStudent(this);
        }
    }
    
    // 其他方法...
}

// 教師類別
public class Teacher extends Person {
    private String department;
    private List<Course> teachingCourses;
    
    public Teacher(String name, String id, int age, String department) {
        super(name, id, age);
        this.department = department;
        this.teachingCourses = new ArrayList<>();
    }
    
    @Override
    public void displayInfo() {
        System.out.println("教師資訊:");
        System.out.println("姓名: " + name);
        System.out.println("員工編號: " + id);
        System.out.println("年齡: " + age);
        System.out.println("系所: " + department);
    }
    
    public void assignCourse(Course course) {
        teachingCourses.add(course);
        course.setTeacher(this);
    }
}

作為一個 [顧客]
我想要 [瀏覽書籍並加入購物車]
以便於 [選購我想要的書籍]

驗收標準：
- 可以依分類瀏覽書籍
- 可以搜尋特定書籍
- 可以查看書籍詳細資訊
- 可以將書籍加入購物車
- 可以調整購物車中的商品數量

/**
 * 線上書店領域模型
 */

// 核心實體
public class Book {
    private String isbn;
    private String title;
    private String author;
    private String publisher;
    private BigDecimal price;
    private int stockQuantity;
    private Category category;
}

public class Customer {
    private String customerId;
    private String name;
    private String email;
    private String phone;
    private List<Address> addresses;
    private ShoppingCart cart;
}

public class Order {
    private String orderId;
    private Customer customer;
    private List<OrderItem> items;
    private OrderStatus status;
    private BigDecimal totalAmount;
    private LocalDateTime orderDate;
    private Payment payment;
}

// 值物件 (Value Objects)
public class Address {
    private String street;
    private String city;
    private String postalCode;
    private String country;
}

public class OrderItem {
    private Book book;
    private int quantity;
    private BigDecimal unitPrice;
}

"顧客可以瀏覽書籍目錄，選擇書籍加入購物車，然後進行結帳。
系統會檢查庫存，處理付款，並產生訂單。"

類別名稱: Customer
職責:
- 瀏覽書籍
- 管理購物車
- 下訂單
- 查看訂單歷史

協作者:
- Book
- ShoppingCart
- Order
- Catalog

// 策略介面
public interface PaymentStrategy {
    boolean processPayment(BigDecimal amount, PaymentDetails details);
}

// 具體策略
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public boolean processPayment(BigDecimal amount, PaymentDetails details) {
        // 信用卡付款邏輯
        System.out.println("使用信用卡付款: " + amount);
        return true;
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public boolean processPayment(BigDecimal amount, PaymentDetails details) {
        // PayPal 付款邏輯
        System.out.println("使用 PayPal 付款: " + amount);
        return true;
    }
}

// 上下文類別
public class PaymentProcessor {
    private PaymentStrategy strategy;
    
    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public boolean processPayment(BigDecimal amount, PaymentDetails details) {
        return strategy.processPayment(amount, details);
    }
}

public interface InventoryObserver {
    void onStockLevelChanged(String bookId, int newLevel);
}

public class InventoryManager {
    private List<InventoryObserver> observers = new ArrayList<>();
    private Map<String, Integer> stockLevels = new HashMap<>();
    
    public void addObserver(InventoryObserver observer) {
        observers.add(observer);
    }
    
    public void updateStock(String bookId, int newLevel) {
        stockLevels.put(bookId, newLevel);
        notifyObservers(bookId, newLevel);
    }
    
    private void notifyObservers(String bookId, int newLevel) {
        for (InventoryObserver observer : observers) {
            observer.onStockLevelChanged(bookId, newLevel);
        }
    }
}

// 觀察者實作
public class LowStockNotifier implements InventoryObserver {
    private static final int LOW_STOCK_THRESHOLD = 10;
    
    @Override
    public void onStockLevelChanged(String bookId, int newLevel) {
        if (newLevel < LOW_STOCK_THRESHOLD) {
            System.out.println("警告：書籍 " + bookId + " 庫存不足，剩餘 " + newLevel + " 本");
        }
    }
}

/**
 * 訂單服務類別
 * 負責處理所有與訂單相關的業務邏輯
 * 
 * @author 開發團隊
 * @version 1.0
 * @since 2025-09-01
 */
@Service
public class OrderService {
    
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    private final OrderRepository orderRepository;
    private final InventoryService inventoryService;
    private final PaymentService paymentService;
    private final NotificationService notificationService;
    
    /**
     * 建構函式 - 使用依賴注入
     */
    public OrderService(OrderRepository orderRepository, 
                       InventoryService inventoryService,
                       PaymentService paymentService,
                       NotificationService notificationService) {
        this.orderRepository = orderRepository;
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
        this.notificationService = notificationService;
    }
    
    /**
     * 處理訂單
     * 
     * @param customerId 顧客ID
     * @param cartItems 購物車項目
     * @param paymentDetails 付款詳細資訊
     * @return 訂單處理結果
     * @throws OrderProcessingException 當訂單處理失敗時拋出
     */
    @Transactional
    public OrderResult processOrder(String customerId, 
                                  List<CartItem> cartItems, 
                                  PaymentDetails paymentDetails) {
        
        logger.info("開始處理訂單，顧客ID: {}", customerId);
        
        try {
            // 1. 驗證庫存
            validateInventory(cartItems);
            
            // 2. 建立訂單
            Order order = createOrder(customerId, cartItems);
            
            // 3. 處理付款
            PaymentResult paymentResult = paymentService.processPayment(
                order.getTotalAmount(), paymentDetails);
            
            if (!paymentResult.isSuccessful()) {
                throw new PaymentException("付款失敗: " + paymentResult.getErrorMessage());
            }
            
            // 4. 扣減庫存
            inventoryService.reserveItems(cartItems);
            
            // 5. 保存訂單
            order.setStatus(OrderStatus.CONFIRMED);
            order.setPaymentId(paymentResult.getPaymentId());
            orderRepository.save(order);
            
            // 6. 發送通知
            notificationService.sendOrderConfirmation(order);
            
            logger.info("訂單處理完成，訂單ID: {}", order.getOrderId());
            
            return new OrderResult(true, order.getOrderId(), "訂單處理成功");
            
        } catch (Exception e) {
            logger.error("訂單處理失敗，顧客ID: {}", customerId, e);
            // 回滾操作
            rollbackOrder(customerId);
            throw new OrderProcessingException("訂單處理失敗", e);
        }
    }
    
    /**
     * 驗證庫存是否充足
     */
    private void validateInventory(List<CartItem> cartItems) {
        for (CartItem item : cartItems) {
            if (!inventoryService.isStockAvailable(item.getBookId(), item.getQuantity())) {
                throw new InsufficientStockException(
                    "書籍 " + item.getBookId() + " 庫存不足");
            }
        }
    }
    
    // 其他私有方法...
}

/**
 * 訂單服務單元測試
 */
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    
    @Mock
    private OrderRepository orderRepository;
    
    @Mock
    private InventoryService inventoryService;
    
    @Mock
    private PaymentService paymentService;
    
    @Mock
    private NotificationService notificationService;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    @DisplayName("成功處理訂單")
    void shouldProcessOrderSuccessfully() {
        // Given
        String customerId = "CUST001";
        List<CartItem> cartItems = createTestCartItems();
        PaymentDetails paymentDetails = createTestPaymentDetails();
        
        when(inventoryService.isStockAvailable(anyString(), anyInt())).thenReturn(true);
        when(paymentService.processPayment(any(), any()))
            .thenReturn(new PaymentResult(true, "PAY001", null));
        when(orderRepository.save(any(Order.class)))
            .thenAnswer(invocation -> invocation.getArgument(0));
        
        // When
        OrderResult result = orderService.processOrder(customerId, cartItems, paymentDetails);
        
        // Then
        assertThat(result.isSuccessful()).isTrue();
        assertThat(result.getOrderId()).isNotBlank();
        
        verify(inventoryService).reserveItems(cartItems);
        verify(orderRepository).save(any(Order.class));
        verify(notificationService).sendOrderConfirmation(any(Order.class));
    }
    
    @Test
    @DisplayName("庫存不足時應拋出例外")
    void shouldThrowExceptionWhenInsufficientStock() {
        // Given
        String customerId = "CUST001";
        List<CartItem> cartItems = createTestCartItems();
        PaymentDetails paymentDetails = createTestPaymentDetails();
        
        when(inventoryService.isStockAvailable(anyString(), anyInt())).thenReturn(false);
        
        // When & Then
        assertThatThrownBy(() -> orderService.processOrder(customerId, cartItems, paymentDetails))
            .isInstanceOf(InsufficientStockException.class)
            .hasMessageContaining("庫存不足");
    }
    
    private List<CartItem> createTestCartItems() {
        return Arrays.asList(
            new CartItem("BOOK001", "Java 程式設計", 2, new BigDecimal("500")),
            new CartItem("BOOK002", "Spring Boot 實戰", 1, new BigDecimal("600"))
        );
    }
    
    private PaymentDetails createTestPaymentDetails() {
        return PaymentDetails.builder()
            .method(PaymentMethod.CREDIT_CARD)
            .cardNumber("4111111111111111")
            .expiryDate("12/25")
            .cvv("123")
            .build();
    }
}

@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
@Testcontainers
class OrderServiceIntegrationTest {
    
    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:13")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private TestEntityManager entityManager;
    
    @Test
    @Transactional
    @DisplayName("完整訂單流程整合測試")
    void shouldCompleteFullOrderFlow() {
        // Given - 準備測試資料
        Customer customer = createTestCustomer();
        Book book = createTestBook();
        entityManager.persistAndFlush(customer);
        entityManager.persistAndFlush(book);
        
        List<CartItem> cartItems = Arrays.asList(
            new CartItem(book.getIsbn(), book.getTitle(), 1, book.getPrice())
        );
        
        PaymentDetails paymentDetails = createValidPaymentDetails();
        
        // When - 執行訂單處理
        OrderResult result = orderService.processOrder(
            customer.getCustomerId(), cartItems, paymentDetails);
        
        // Then - 驗證結果
        assertThat(result.isSuccessful()).isTrue();
        
        // 驗證資料庫狀態
        Order savedOrder = entityManager.find(Order.class, result.getOrderId());
        assertThat(savedOrder).isNotNull();
        assertThat(savedOrder.getStatus()).isEqualTo(OrderStatus.CONFIRMED);
        assertThat(savedOrder.getItems()).hasSize(1);
    }
}

/**
 * Use Case: 顧客下訂單
 * 
 * 前置條件: 顧客已登入，購物車有商品
 * 主要流程:
 * 1. 顧客選擇結帳
 * 2. 系統顯示訂單摘要
 * 3. 顧客確認訂單
 * 4. 系統處理付款
 * 5. 系統確認訂單
 */
@UseCase("顧客下訂單")
public class PlaceOrderUseCase {
    
    private final OrderService orderService;
    private final PaymentService paymentService;
    
    public OrderResult execute(PlaceOrderRequest request) {
        // 1. 驗證前置條件
        validatePreconditions(request);
        
        // 2. 執行主要流程
        return processOrder(request);
    }
    
    private void validatePreconditions(PlaceOrderRequest request) {
        if (!request.getCustomer().isLoggedIn()) {
            throw new PreconditionFailedException("顧客尚未登入");
        }
        
        if (request.getCart().isEmpty()) {
            throw new PreconditionFailedException("購物車為空");
        }
    }
    
    private OrderResult processOrder(PlaceOrderRequest request) {
        // 實作主要流程邏輯
        Order order = orderService.createOrder(request);
        PaymentResult paymentResult = paymentService.processPayment(order);
        
        if (paymentResult.isSuccessful()) {
            orderService.confirmOrder(order);
            return new OrderResult(true, order.getId());
        } else {
            return new OrderResult(false, paymentResult.getErrorMessage());
        }
    }
}

/**
 * 訂單狀態管理
 */
public enum OrderStatus {
    DRAFT("草稿"),
    PENDING_PAYMENT("待付款"),
    PAYMENT_FAILED("付款失敗"),
    PAID("已付款"),
    PROCESSING("處理中"),
    SHIPPED("已出貨"),
    IN_TRANSIT("運送中"),
    DELIVERED("已送達"),
    COMPLETED("已完成"),
    CANCELLED("已取消"),
    REFUNDED("已退款"),
    RETURN_REQUESTED("退貨中"),
    DELIVERY_FAILED("運送失敗");
    
    private final String description;
    
    OrderStatus(String description) {
        this.description = description;
    }
    
    public String getDescription() {
        return description;
    }
}

/**
 * 訂單狀態機
 */
@Component
public class OrderStateMachine {
    
    private static final Map<OrderStatus, Set<OrderStatus>> VALID_TRANSITIONS = Map.of(
        DRAFT, Set.of(PENDING_PAYMENT, CANCELLED),
        PENDING_PAYMENT, Set.of(PAID, PAYMENT_FAILED, CANCELLED),
        PAYMENT_FAILED, Set.of(PENDING_PAYMENT, CANCELLED),
        PAID, Set.of(PROCESSING, REFUNDED),
        PROCESSING, Set.of(SHIPPED, CANCELLED),
        SHIPPED, Set.of(IN_TRANSIT),
        IN_TRANSIT, Set.of(DELIVERED, DELIVERY_FAILED),
        DELIVERY_FAILED, Set.of(IN_TRANSIT, REFUNDED),
        DELIVERED, Set.of(COMPLETED, RETURN_REQUESTED),
        RETURN_REQUESTED, Set.of(REFUNDED, COMPLETED)
    );
    
    /**
     * 驗證狀態轉換是否有效
     */
    public boolean isValidTransition(OrderStatus from, OrderStatus to) {
        Set<OrderStatus> validNextStates = VALID_TRANSITIONS.get(from);
        return validNextStates != null && validNextStates.contains(to);
    }
    
    /**
     * 執行狀態轉換
     */
    public void transitionState(Order order, OrderStatus newStatus, String reason) {
        OrderStatus currentStatus = order.getStatus();
        
        if (!isValidTransition(currentStatus, newStatus)) {
            throw new InvalidStateTransitionException(
                String.format("無法從 %s 轉換到 %s", 
                    currentStatus.getDescription(), 
                    newStatus.getDescription())
            );
        }
        
        // 執行狀態轉換前的動作
        executePreTransitionActions(order, currentStatus, newStatus);
        
        // 更新狀態
        order.setStatus(newStatus);
        order.addStatusHistory(new StatusHistory(currentStatus, newStatus, reason, LocalDateTime.now()));
        
        // 執行狀態轉換後的動作
        executePostTransitionActions(order, currentStatus, newStatus);
        
        log.info("訂單 {} 狀態從 {} 轉換為 {}, 原因: {}", 
            order.getOrderId(), 
            currentStatus.getDescription(), 
            newStatus.getDescription(), 
            reason);
    }
    
    private void executePreTransitionActions(Order order, OrderStatus from, OrderStatus to) {
        switch (to) {
            case PROCESSING:
                // 檢查庫存並保留
                inventoryService.reserveItems(order.getItems());
                break;
            case SHIPPED:
                // 扣減庫存
                inventoryService.commitReservation(order.getItems());
                break;
            case CANCELLED:
                // 釋放保留的庫存
                if (from == PROCESSING) {
                    inventoryService.releaseReservation(order.getItems());
                }
                break;
        }
    }
    
    private void executePostTransitionActions(Order order, OrderStatus from, OrderStatus to) {
        switch (to) {
            case PAID:
                notificationService.sendPaymentConfirmation(order);
                break;
            case SHIPPED:
                notificationService.sendShippingNotification(order);
                break;
            case DELIVERED:
                notificationService.sendDeliveryConfirmation(order);
                break;
            case CANCELLED:
                notificationService.sendCancellationNotification(order);
                break;
        }
    }
}

/**
 * 領域模型 - 課程管理系統
 */

// 抽象基類
public abstract class User {
    protected String userId;
    protected String name;
    protected String email;
    protected String phone;
    protected UserRole role;
    protected LocalDateTime createdAt;
    protected boolean active;
    
    // 建構函式和基本方法
    public User(String userId, String name, String email, UserRole role) {
        this.userId = userId;
        this.name = name;
        this.email = email;
        this.role = role;
        this.createdAt = LocalDateTime.now();
        this.active = true;
    }
    
    public abstract boolean canEnroll(Course course);
    public abstract List<Course> getEnrolledCourses();
}

// 學生實體
public class Student extends User {
    private String studentId;
    private String major;
    private int year;
    private double gpa;
    private int totalCredits;
    private Set<Enrollment> enrollments;
    
    public Student(String userId, String name, String email, String studentId, String major) {
        super(userId, name, email, UserRole.STUDENT);
        this.studentId = studentId;
        this.major = major;
        this.year = 1;
        this.gpa = 0.0;
        this.totalCredits = 0;
        this.enrollments = new HashSet<>();
    }
    
    @Override
    public boolean canEnroll(Course course) {
        // 檢查選課條件
        return !hasTimeConflict(course) && 
               !isEnrolled(course) && 
               hasPrerequisites(course) &&
               getTotalCreditsThisSemester() + course.getCredits() <= 25;
    }
    
    @Override
    public List<Course> getEnrolledCourses() {
        return enrollments.stream()
            .filter(e -> e.getStatus() == EnrollmentStatus.ENROLLED)
            .map(Enrollment::getCourse)
            .collect(Collectors.toList());
    }
    
    public EnrollmentResult enrollInCourse(Course course) {
        if (!canEnroll(course)) {
            return EnrollmentResult.failure("不符合選課條件");
        }
        
        if (course.isFull()) {
            return EnrollmentResult.failure("課程人數已滿");
        }
        
        Enrollment enrollment = new Enrollment(this, course, LocalDateTime.now());
        enrollments.add(enrollment);
        course.addStudent(this);
        
        return EnrollmentResult.success(enrollment);
    }
    
    private boolean hasTimeConflict(Course course) {
        return getEnrolledCourses().stream()
            .anyMatch(enrolled -> enrolled.hasTimeConflictWith(course));
    }
    
    private boolean isEnrolled(Course course) {
        return enrollments.stream()
            .anyMatch(e -> e.getCourse().equals(course) && 
                          e.getStatus() == EnrollmentStatus.ENROLLED);
    }
    
    private boolean hasPrerequisites(Course course) {
        Set<Course> prerequisites = course.getPrerequisites();
        Set<Course> completedCourses = getCompletedCourses();
        return completedCourses.containsAll(prerequisites);
    }
    
    private Set<Course> getCompletedCourses() {
        return enrollments.stream()
            .filter(e -> e.getGrade() != null && e.getGrade().isPassing())
            .map(Enrollment::getCourse)
            .collect(Collectors.toSet());
    }
    
    private int getTotalCreditsThisSemester() {
        return enrollments.stream()
            .filter(e -> e.getSemester().isCurrent())
            .mapToInt(e -> e.getCourse().getCredits())
            .sum();
    }
}

// 教師實體
public class Teacher extends User {
    private String employeeId;
    private String department;
    private String title;
    private Set<Course> teachingCourses;
    
    public Teacher(String userId, String name, String email, String employeeId, String department) {
        super(userId, name, email, UserRole.TEACHER);
        this.employeeId = employeeId;
        this.department = department;
        this.teachingCourses = new HashSet<>();
    }
    
    @Override
    public boolean canEnroll(Course course) {
        return false; // 教師不能選課，只能開課
    }
    
    @Override
    public List<Course> getEnrolledCourses() {
        return Collections.emptyList();
    }
    
    public Course createCourse(String courseCode, String title, int credits, int maxStudents) {
        Course course = new Course(courseCode, title, credits, maxStudents, this);
        teachingCourses.add(course);
        return course;
    }
    
    public void assignGrade(Student student, Course course, double score) {
        Enrollment enrollment = findEnrollment(student, course);
        if (enrollment != null) {
            Grade grade = new Grade(score, calculateLetterGrade(score));
            enrollment.setGrade(grade);
        }
    }
    
    private Enrollment findEnrollment(Student student, Course course) {
        return course.getEnrollments().stream()
            .filter(e -> e.getStudent().equals(student))
            .findFirst()
            .orElse(null);
    }
    
    private String calculateLetterGrade(double score) {
        if (score >= 90) return "A";
        if (score >= 80) return "B";
        if (score >= 70) return "C";
        if (score >= 60) return "D";
        return "F";
    }
}

// 課程實體
public class Course {
    private String courseId;
    private String courseCode;  // 課程代碼，如 "CS101"
    private String title;
    private String description;
    private int credits;
    private int maxStudents;
    private Teacher instructor;
    private Set<Student> enrolledStudents;
    private Set<Enrollment> enrollments;
    private Set<Course> prerequisites;
    private List<TimeSlot> timeSlots;
    private String location;
    private Semester semester;
    private CourseStatus status;
    
    public Course(String courseCode, String title, int credits, int maxStudents, Teacher instructor) {
        this.courseId = UUID.randomUUID().toString();
        this.courseCode = courseCode;
        this.title = title;
        this.credits = credits;
        this.maxStudents = maxStudents;
        this.instructor = instructor;
        this.enrolledStudents = new HashSet<>();
        this.enrollments = new HashSet<>();
        this.prerequisites = new HashSet<>();
        this.timeSlots = new ArrayList<>();
        this.status = CourseStatus.DRAFT;
    }
    
    public boolean isFull() {
        return enrolledStudents.size() >= maxStudents;
    }
    
    public boolean isAvailable() {
        return status == CourseStatus.OPEN && !isFull();
    }
    
    public void addStudent(Student student) {
        if (isFull()) {
            throw new CourseFullException("課程人數已滿");
        }
        enrolledStudents.add(student);
    }
    
    public void removeStudent(Student student) {
        enrolledStudents.remove(student);
    }
    
    public boolean hasTimeConflictWith(Course other) {
        return this.timeSlots.stream()
            .anyMatch(thisSlot -> other.timeSlots.stream()
                .anyMatch(otherSlot -> thisSlot.overlapsWith(otherSlot)));
    }
    
    public void addTimeSlot(DayOfWeek day, LocalTime startTime, LocalTime endTime) {
        TimeSlot slot = new TimeSlot(day, startTime, endTime);
        timeSlots.add(slot);
    }
    
    public int getEnrolledCount() {
        return enrolledStudents.size();
    }
    
    public double getAverageGrade() {
        return enrollments.stream()
            .filter(e -> e.getGrade() != null)
            .mapToDouble(e -> e.getGrade().getNumericScore())
            .average()
            .orElse(0.0);
    }
    
    // Getters and setters...
}

// 選課紀錄實體
public class Enrollment {
    private String enrollmentId;
    private Student student;
    private Course course;
    private Semester semester;
    private LocalDateTime enrollmentDate;
    private EnrollmentStatus status;
    private Grade grade;
    
    public Enrollment(Student student, Course course, LocalDateTime enrollmentDate) {
        this.enrollmentId = UUID.randomUUID().toString();
        this.student = student;
        this.course = course;
        this.enrollmentDate = enrollmentDate;
        this.status = EnrollmentStatus.ENROLLED;
        this.semester = Semester.getCurrentSemester();
    }
    
    public void withdraw() {
        if (status == EnrollmentStatus.ENROLLED) {
            status = EnrollmentStatus.WITHDRAWN;
            course.removeStudent(student);
        }
    }
    
    public boolean isActive() {
        return status == EnrollmentStatus.ENROLLED;
    }
    
    // Getters and setters...
}

// 成績值物件
public class Grade {
    private double numericScore;
    private String letterGrade;
    private LocalDateTime gradedDate;
    private String comments;
    
    public Grade(double numericScore, String letterGrade) {
        this.numericScore = numericScore;
        this.letterGrade = letterGrade;
        this.gradedDate = LocalDateTime.now();
        validateGrade();
    }
    
    private void validateGrade() {
        if (numericScore < 0 || numericScore > 100) {
            throw new IllegalArgumentException("成績必須在 0-100 之間");
        }
    }
    
    public boolean isPassing() {
        return numericScore >= 60;
    }
    
    public double getGradePoints() {
        switch (letterGrade) {
            case "A": return 4.0;
            case "B": return 3.0;
            case "C": return 2.0;
            case "D": return 1.0;
            default: return 0.0;
        }
    }
    
    // Getters and setters...
}

// 時間區間值物件
public class TimeSlot {
    private DayOfWeek dayOfWeek;
    private LocalTime startTime;
    private LocalTime endTime;
    
    public TimeSlot(DayOfWeek dayOfWeek, LocalTime startTime, LocalTime endTime) {
        this.dayOfWeek = dayOfWeek;
        this.startTime = startTime;
        this.endTime = endTime;
        validateTimeSlot();
    }
    
    private void validateTimeSlot() {
        if (startTime.isAfter(endTime)) {
            throw new IllegalArgumentException("開始時間不能晚於結束時間");
        }
    }
    
    public boolean overlapsWith(TimeSlot other) {
        if (!this.dayOfWeek.equals(other.dayOfWeek)) {
            return false;
        }
        
        return this.startTime.isBefore(other.endTime) && 
               this.endTime.isAfter(other.startTime);
    }
    
    public Duration getDuration() {
        return Duration.between(startTime, endTime);
    }
    
    @Override
    public String toString() {
        return String.format("%s %s-%s", 
            dayOfWeek.getDisplayName(TextStyle.SHORT, Locale.TRADITIONAL_CHINESE),
            startTime.format(DateTimeFormatter.ofPattern("HH:mm")),
            endTime.format(DateTimeFormatter.ofPattern("HH:mm")));
    }
    
    // Getters and setters...
}

// 枚舉定義
public enum UserRole {
    STUDENT("學生"),
    TEACHER("教師"), 
    ADMIN("管理員");
    
    private final String displayName;
    
    UserRole(String displayName) {
        this.displayName = displayName;
    }
    
    public String getDisplayName() {
        return displayName;
    }
}

public enum EnrollmentStatus {
    ENROLLED("已選課"),
    WITHDRAWN("已退選"),
    WAITLISTED("候補中");
    
    private final String displayName;
    
    EnrollmentStatus(String displayName) {
        this.displayName = displayName;
    }
    
    public String getDisplayName() {
        return displayName;
    }
}

public enum CourseStatus {
    DRAFT("草稿"),
    OPEN("開放選課"),
    CLOSED("關閉選課"),
    IN_PROGRESS("進行中"),
    COMPLETED("已結束");
    
    private final String displayName;
    
    CourseStatus(String displayName) {
        this.displayName = displayName;
    }
    
    public String getDisplayName() {
        return displayName;
    }
}

@Service
@Transactional
public class EnrollmentService {
    
    private final StudentRepository studentRepository;
    private final CourseRepository courseRepository;
    private final EnrollmentRepository enrollmentRepository;
    private final NotificationService notificationService;
    private final EnrollmentValidator enrollmentValidator;
    
    public EnrollmentService(StudentRepository studentRepository,
                           CourseRepository courseRepository,
                           EnrollmentRepository enrollmentRepository,
                           NotificationService notificationService,
                           EnrollmentValidator enrollmentValidator) {
        this.studentRepository = studentRepository;
        this.courseRepository = courseRepository;
        this.enrollmentRepository = enrollmentRepository;
        this.notificationService = notificationService;
        this.enrollmentValidator = enrollmentValidator;
    }
    
    /**
     * 學生選課
     */
    public EnrollmentResult enrollStudent(String studentId, String courseId) {
        try {
            // 1. 載入學生和課程
            Student student = studentRepository.findById(studentId)
                .orElseThrow(() -> new StudentNotFoundException("學生不存在: " + studentId));
            
            Course course = courseRepository.findById(courseId)
                .orElseThrow(() -> new CourseNotFoundException("課程不存在: " + courseId));
            
            // 2. 驗證選課條件
            ValidationResult validationResult = enrollmentValidator.validate(student, course);
            if (!validationResult.isValid()) {
                return EnrollmentResult.failure(validationResult.getErrors());
            }
            
            // 3. 檢查課程是否還有名額
            if (course.isFull()) {
                return handleWaitlist(student, course);
            }
            
            // 4. 執行選課
            Enrollment enrollment = student.enrollInCourse(course);
            enrollmentRepository.save(enrollment);
            
            // 5. 更新課程選課人數
            courseRepository.save(course);
            
            // 6. 發送通知
            notificationService.sendEnrollmentConfirmation(student, course);
            
            log.info("學生 {} 成功選修課程 {}", studentId, courseId);
            return EnrollmentResult.success(enrollment);
            
        } catch (Exception e) {
            log.error("選課失敗: studentId={}, courseId={}", studentId, courseId, e);
            return EnrollmentResult.failure("系統錯誤，請稍後再試");
        }
    }
    
    /**
     * 處理候補邏輯
     */
    private EnrollmentResult handleWaitlist(Student student, Course course) {
        if (!course.isWaitlistEnabled()) {
            return EnrollmentResult.failure("課程人數已滿且不開放候補");
        }
        
        Enrollment waitlistEnrollment = new Enrollment(student, course, LocalDateTime.now());
        waitlistEnrollment.setStatus(EnrollmentStatus.WAITLISTED);
        enrollmentRepository.save(waitlistEnrollment);
        
        notificationService.sendWaitlistNotification(student, course);
        
        return EnrollmentResult.waitlisted(waitlistEnrollment, course.getWaitlistPosition(student));
    }
    
    /**
     * 學生退選
     */
    public WithdrawalResult withdrawStudent(String studentId, String courseId) {
        try {
            Enrollment enrollment = enrollmentRepository
                .findByStudentIdAndCourseId(studentId, courseId)
                .orElseThrow(() -> new EnrollmentNotFoundException("選課紀錄不存在"));
            
            // 檢查是否可以退選
            if (!canWithdraw(enrollment)) {
                return WithdrawalResult.failure("已過退選期限或課程已開始");
            }
            
            // 執行退選
            enrollment.withdraw();
            enrollmentRepository.save(enrollment);
            
            // 處理候補學生
            processWaitlist(enrollment.getCourse());
            
            // 發送通知
            notificationService.sendWithdrawalConfirmation(enrollment.getStudent(), enrollment.getCourse());
            
            log.info("學生 {} 成功退選課程 {}", studentId, courseId);
            return WithdrawalResult.success();
            
        } catch (Exception e) {
            log.error("退選失敗: studentId={}, courseId={}", studentId, courseId, e);
            return WithdrawalResult.failure("系統錯誤，請稍後再試");
        }
    }
    
    /**
     * 處理候補名單
     */
    private void processWaitlist(Course course) {
        List<Enrollment> waitlistEnrollments = enrollmentRepository
            .findWaitlistByCourseOrderByEnrollmentDate(course.getCourseId());
        
        if (!waitlistEnrollments.isEmpty() && !course.isFull()) {
            Enrollment nextEnrollment = waitlistEnrollments.get(0);
            nextEnrollment.setStatus(EnrollmentStatus.ENROLLED);
            enrollmentRepository.save(nextEnrollment);
            
            course.addStudent(nextEnrollment.getStudent());
            courseRepository.save(course);
            
            notificationService.sendWaitlistPromotion(
                nextEnrollment.getStudent(), 
                nextEnrollment.getCourse()
            );
        }
    }
    
    private boolean canWithdraw(Enrollment enrollment) {
        // 業務規則：開課後一週內可退選
        LocalDateTime courseStartDate = enrollment.getCourse().getStartDate();
        LocalDateTime withdrawalDeadline = courseStartDate.plusWeeks(1);
        return LocalDateTime.now().isBefore(withdrawalDeadline);
    }
    
    /**
     * 取得學生的選課列表
     */
    @Transactional(readOnly = true)
    public List<EnrollmentDTO> getStudentEnrollments(String studentId, String semesterId) {
        List<Enrollment> enrollments = enrollmentRepository
            .findByStudentIdAndSemesterId(studentId, semesterId);
        
        return enrollments.stream()
            .map(this::convertToDTO)
            .collect(Collectors.toList());
    }
    
    /**
     * 取得課程的選課名單
     */
    @Transactional(readOnly = true)
    public List<StudentEnrollmentDTO> getCourseEnrollments(String courseId) {
        List<Enrollment> enrollments = enrollmentRepository
            .findByCourseIdAndStatus(courseId, EnrollmentStatus.ENROLLED);
        
        return enrollments.stream()
            .map(this::convertToStudentEnrollmentDTO)
            .sorted(Comparator.comparing(StudentEnrollmentDTO::getStudentName))
            .collect(Collectors.toList());
    }
    
    private EnrollmentDTO convertToDTO(Enrollment enrollment) {
        return EnrollmentDTO.builder()
            .enrollmentId(enrollment.getEnrollmentId())
            .courseCode(enrollment.getCourse().getCourseCode())
            .courseTitle(enrollment.getCourse().getTitle())
            .credits(enrollment.getCourse().getCredits())
            .instructor(enrollment.getCourse().getInstructor().getName())
            .status(enrollment.getStatus())
            .enrollmentDate(enrollment.getEnrollmentDate())
            .grade(enrollment.getGrade() != null ? 
                   enrollment.getGrade().getLetterGrade() : null)
            .build();
    }
    
    private StudentEnrollmentDTO convertToStudentEnrollmentDTO(Enrollment enrollment) {
        Student student = enrollment.getStudent();
        return StudentEnrollmentDTO.builder()
            .studentId(student.getStudentId())
            .studentName(student.getName())
            .year(student.getYear())
            .major(student.getMajor())
            .enrollmentDate(enrollment.getEnrollmentDate())
            .grade(enrollment.getGrade() != null ? 
                   enrollment.getGrade().getLetterGrade() : null)
            .build();
    }
}

@Component
public class EnrollmentValidator {
    
    /**
     * 驗證學生是否可以選修課程
     */
    public ValidationResult validate(Student student, Course course) {
        List<String> errors = new ArrayList<>();
        
        // 1. 檢查基本條件
        if (!course.isAvailable()) {
            errors.add("課程目前不開放選課");
        }
        
        if (student.isEnrolledIn(course)) {
            errors.add("您已經選修此課程");
        }
        
        // 2. 檢查先修課程
        if (!hasPrerequisites(student, course)) {
            errors.add("尚未完成先修課程要求");
        }
        
        // 3. 檢查學分限制
        if (exceedsCreditLimit(student, course)) {
            errors.add("選修此課程將超過學分上限");
        }
        
        // 4. 檢查時間衝突
        List<Course> conflictingCourses = findTimeConflicts(student, course);
        if (!conflictingCourses.isEmpty()) {
            String conflictNames = conflictingCourses.stream()
                .map(Course::getTitle)
                .collect(Collectors.joining(", "));
            errors.add("與以下課程時間衝突: " + conflictNames);
        }
        
        // 5. 檢查年級限制
        if (!meetsYearRequirement(student, course)) {
            errors.add("年級不符合選課要求");
        }
        
        return new ValidationResult(errors.isEmpty(), errors);
    }
    
    /**
     * 檢查先修課程
     */
    private boolean hasPrerequisites(Student student, Course course) {
        Set<Course> prerequisites = course.getPrerequisites();
        if (prerequisites.isEmpty()) {
            return true;
        }
        
        Set<Course> completedCourses = student.getCompletedCourses();
        return completedCourses.containsAll(prerequisites);
    }
    
    /**
     * 檢查學分限制
     */
    private boolean exceedsCreditLimit(Student student, Course course) {
        int currentCredits = student.getTotalCreditsThisSemester();
        int maxCredits = getMaxCreditsForYear(student.getYear());
        
        return (currentCredits + course.getCredits()) > maxCredits;
    }
    
    /**
     * 找出時間衝突的課程
     */
    private List<Course> findTimeConflicts(Student student, Course course) {
        List<Course> enrolledCourses = student.getEnrolledCoursesThisSemester();
        
        return enrolledCourses.stream()
            .filter(enrolled -> enrolled.hasTimeConflictWith(course))
            .collect(Collectors.toList());
    }
    
    private boolean meetsYearRequirement(Student student, Course course) {
        if (course.getMinYear() == null) {
            return true;
        }
        return student.getYear() >= course.getMinYear();
    }
    
    private int getMaxCreditsForYear(int year) {
        // 業務規則：不同年級有不同的學分上限
        switch (year) {
            case 1: return 22;
            case 2: return 25;
            case 3: 
            case 4: return 28;
            default: return 25;
        }
    }
}

/**
 * 驗證結果
 */
public class ValidationResult {
    private final boolean valid;
    private final List<String> errors;
    
    public ValidationResult(boolean valid, List<String> errors) {
        this.valid = valid;
        this.errors = errors != null ? errors : Collections.emptyList();
    }
    
    public static ValidationResult success() {
        return new ValidationResult(true, Collections.emptyList());
    }
    
    public static ValidationResult failure(String error) {
        return new ValidationResult(false, Arrays.asList(error));
    }
    
    public static ValidationResult failure(List<String> errors) {
        return new ValidationResult(false, errors);
    }
    
    // Getters...
    public boolean isValid() { return valid; }
    public List<String> getErrors() { return errors; }
    
    public String getErrorMessage() {
        return String.join("; ", errors);
    }
}

錯誤理解: "系統需要一個登入功能"
正確理解: "系統需要安全的身份驗證機制，支援多種認證方式，包括單一登入(SSO)，並需要符合資安政策"

// 好的需求描述
@RequirementSpec
public class UserAuthenticationRequirement {
    /**
     * FR-001: 使用者身份驗證
     * 
     * 描述: 系統必須提供安全的使用者身份驗證機制
     * 
     * 功能需求:
     * - 支援使用者名稱/密碼登入
     * - 支援 LDAP 整合
     * - 支援多因素驗證 (MFA)
     * - 提供密碼重設功能
     * 
     * 非功能需求:
     * - 登入回應時間 < 2 秒
     * - 密碼必須符合複雜度要求
     * - 登入失敗三次後鎖定帳號
     * - 符合 GDPR 法規要求
     * 
     * 驗收標準:
     * - 成功登入後導向儀表板
     * - 失敗登入顯示適當錯誤訊息
     * - 所有認證事件被記錄
     */
}

// 錯誤：在領域模型中混入技術細節
public class User {
    @Entity
    @Table(name = "users")
    private String userId;
    
    @JsonIgnore
    private String password;
    
    @Autowired
    private UserRepository repository; // 領域物件不應該依賴基礎設施
}

// 正確：純粹的領域模型
public class User {
    private String userId;
    private String name;
    private String email;
    private UserRole role;
    
    public User(String userId, String name, String email, UserRole role) {
        this.userId = userId;
        this.name = name;
        this.email = email;
        this.role = role;
    }
    
    public boolean canAccessResource(Resource resource) {
        return role.hasPermission(resource.getRequiredPermission());
    }
    
    // 純粹的業務邏輯，不涉及技術實作
}

// 使用領域專用的術語和概念
public class LoanApplication {
    private LoanApplicationNumber applicationNumber;
    private Borrower primaryBorrower;
    private LoanAmount requestedAmount;
    private CreditScore creditScore;
    private CollateralValuation collateral;
    
    public UnderwritingDecision performUnderwriting() {
        // 使用真實的業務規則
        if (creditScore.isBelow(MINIMUM_CREDIT_SCORE)) {
            return UnderwritingDecision.decline("信用評分不足");
        }
        
        if (debtToIncomeRatio().exceeds(MAXIMUM_DTI_RATIO)) {
            return UnderwritingDecision.decline("負債收入比過高");
        }
        
        return UnderwritingDecision.approve();
    }
}

// 錯誤：UserManager 做了太多事情
public class UserManager {
    public void createUser(User user) { /* ... */ }
    public void updateUser(User user) { /* ... */ }
    public void deleteUser(String userId) { /* ... */ }
    public User findUser(String userId) { /* ... */ }
    public void sendWelcomeEmail(User user) { /* ... */ }
    public void validatePassword(String password) { /* ... */ }
    public void generateReport() { /* ... */ }
    public void backupUserData() { /* ... */ }
}

// 正確：職責分離
public class UserService {
    private final UserRepository userRepository;
    private final PasswordValidator passwordValidator;
    private final NotificationService notificationService;
    
    public UserCreationResult createUser(CreateUserRequest request) {
        // 只負責使用者建立的業務邏輯
        ValidationResult validation = passwordValidator.validate(request.getPassword());
        if (!validation.isValid()) {
            return UserCreationResult.failure(validation.getErrors());
        }
        
        User user = new User(request.getName(), request.getEmail(), request.getPassword());
        userRepository.save(user);
        
        notificationService.sendWelcomeNotification(user);
        
        return UserCreationResult.success(user);
    }
}

public class PasswordValidator {
    public ValidationResult validate(String password) {
        // 只負責密碼驗證邏輯
    }
}

public class UserReportService {
    public UserReport generateUserReport(ReportCriteria criteria) {
        // 只負責報表產生
    }
}

// 錯誤：緊耦合
public class OrderService {
    public void processOrder(Order order) {
        // 直接相依具體實作
        EmailService emailService = new EmailService();
        PaymentService paymentService = new CreditCardPaymentService();
        InventoryService inventoryService = new DatabaseInventoryService();
        
        // 處理邏輯...
    }
}

// 正確：鬆耦合設計
public class OrderService {
    private final NotificationService notificationService;
    private final PaymentService paymentService;
    private final InventoryService inventoryService;
    
    public OrderService(NotificationService notificationService,
                       PaymentService paymentService,
                       InventoryService inventoryService) {
        this.notificationService = notificationService;
        this.paymentService = paymentService;
        this.inventoryService = inventoryService;
    }
    
    public OrderResult processOrder(Order order) {
        // 透過介面操作，具體實作可替換
        if (!inventoryService.isAvailable(order.getItems())) {
            return OrderResult.failure("庫存不足");
        }
        
        PaymentResult payment = paymentService.processPayment(order.getAmount());
        if (payment.isSuccessful()) {
            inventoryService.reserveItems(order.getItems());
            notificationService.sendOrderConfirmation(order);
            return OrderResult.success(order);
        }
        
        return OrderResult.failure("付款失敗");
    }
}

// 介面定義
public interface PaymentService {
    PaymentResult processPayment(BigDecimal amount);
}

public interface NotificationService {
    void sendOrderConfirmation(Order order);
}

// 設計異常階層
public abstract class BusinessException extends Exception {
    private final String errorCode;
    private final String userMessage;
    
    public BusinessException(String errorCode, String userMessage, String debugMessage) {
        super(debugMessage);
        this.errorCode = errorCode;
        this.userMessage = userMessage;
    }
    
    // Getters...
}

public class InsufficientInventoryException extends BusinessException {
    public InsufficientInventoryException(String productId, int requestedQuantity, int availableQuantity) {
        super("INV_001", 
              "商品庫存不足", 
              String.format("Product %s: requested %d, available %d", productId, requestedQuantity, availableQuantity));
    }
}

public class PaymentProcessingException extends BusinessException {
    public PaymentProcessingException(String reason) {
        super("PAY_001", "付款處理失敗", reason);
    }
}

// 在服務中使用
public class OrderService {
    public OrderResult processOrder(Order order) throws BusinessException {
        try {
            validateInventory(order);
            processPayment(order);
            fulfillOrder(order);
            return OrderResult.success(order);
        } catch (InsufficientInventoryException e) {
            log.warn("Order failed due to insufficient inventory: {}", e.getMessage());
            return OrderResult.failure(e.getUserMessage());
        } catch (PaymentProcessingException e) {
            log.error("Payment processing failed: {}", e.getMessage());
            return OrderResult.failure(e.getUserMessage());
        } catch (Exception e) {
            log.error("Unexpected error processing order: {}", e.getMessage(), e);
            return OrderResult.failure("系統暫時無法處理您的訂單，請稍後再試");
        }
    }
}

// 錯誤：非執行緒安全的實作
public class CounterService {
    private int count = 0;
    
    public int increment() {
        count++; // 非原子操作，在多執行緒環境中不安全
        return count;
    }
}

// 正確：執行緒安全的實作
public class CounterService {
    private final AtomicInteger count = new AtomicInteger(0);
    
    public int increment() {
        return count.incrementAndGet(); // 原子操作
    }
}

// 或使用同步方法
public class BankAccountService {
    private final Object lock = new Object();
    private BigDecimal balance;
    
    public boolean withdraw(BigDecimal amount) {
        synchronized (lock) {
            if (balance.compareTo(amount) >= 0) {
                balance = balance.subtract(amount);
                return true;
            }
            return false;
        }
    }
    
    public void deposit(BigDecimal amount) {
        synchronized (lock) {
            balance = balance.add(amount);
        }
    }
}

// 錯誤：可能造成資源洩漏
public String readFile(String fileName) throws IOException {
    FileInputStream fis = new FileInputStream(fileName);
    BufferedReader reader = new BufferedReader(new InputStreamReader(fis));
    
    StringBuilder content = new StringBuilder();
    String line;
    while ((line = reader.readLine()) != null) {
        content.append(line);
    }
    
    // 忘記關閉資源！
    return content.toString();
}

// 正確：自動資源管理
public String readFile(String fileName) throws IOException {
    try (FileInputStream fis = new FileInputStream(fileName);
         BufferedReader reader = new BufferedReader(new InputStreamReader(fis))) {
        
        StringBuilder content = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            content.append(line).append("\n");
        }
        
        return content.toString();
    } // 資源會自動關閉
}

// 更簡潔的方式
public String readFile(String fileName) throws IOException {
    return Files.readString(Paths.get(fileName));
}

// 錯誤：可能造成大量資料庫查詢
public List<OrderDTO> getOrdersWithCustomers() {
    List<Order> orders = orderRepository.findAll(); // 1 次查詢
    
    return orders.stream()
        .map(order -> {
            Customer customer = customerRepository.findById(order.getCustomerId()); // N 次查詢
            return new OrderDTO(order, customer);
        })
        .collect(Collectors.toList());
}

// 正確：使用 JOIN 或批次查詢
@Repository
public class OrderRepository {
    
    @Query("SELECT o FROM Order o JOIN FETCH o.customer")
    public List<Order> findAllWithCustomers() {
        // 只需 1 次查詢就包含所有需要的資料
    }
}

// 或使用批次查詢
public List<OrderDTO> getOrdersWithCustomers() {
    List<Order> orders = orderRepository.findAll();
    
    // 批次查詢客戶資料
    Set<String> customerIds = orders.stream()
        .map(Order::getCustomerId)
        .collect(Collectors.toSet());
    
    Map<String, Customer> customers = customerRepository
        .findByIdIn(customerIds)
        .stream()
        .collect(Collectors.toMap(Customer::getId, Function.identity()));
    
    return orders.stream()
        .map(order -> {
            Customer customer = customers.get(order.getCustomerId());
            return new OrderDTO(order, customer);
        })
        .collect(Collectors.toList());
}

// 類別命名
public class OrderService { }          // 服務類別
public class OrderRepository { }       // 資料存取類別
public class OrderDTO { }             // 資料傳輸物件
public class OrderValidator { }       // 驗證類別
public class OrderException { }       // 異常類別

// 方法命名
public Order createOrder() { }        // 建立操作用 create
public Order findById(String id) { }  // 查詢操作用 find
public void updateOrder() { }         // 更新操作用 update
public void deleteOrder() { }         // 刪除操作用 delete

// 好的範例：清楚的變數名稱和方法名稱
public class LoanApplicationProcessor {
    
    private static final BigDecimal MINIMUM_CREDIT_SCORE = new BigDecimal("650");
    private static final BigDecimal MAXIMUM_DEBT_TO_INCOME_RATIO = new BigDecimal("0.43");
    
    public UnderwritingDecision evaluateLoanApplication(LoanApplication application) {
        if (hasInsufficientCreditScore(application)) {
            return UnderwritingDecision.decline("信用評分不足");
        }
        
        if (hasExcessiveDebtToIncomeRatio(application)) {
            return UnderwritingDecision.decline("負債收入比過高");
        }
        
        if (lacksAdequateCollateral(application)) {
            return UnderwritingDecision.decline("擔保品價值不足");
        }
        
        return UnderwritingDecision.approve();
    }
    
    private boolean hasInsufficientCreditScore(LoanApplication application) {
        return application.getBorrower().getCreditScore().compareTo(MINIMUM_CREDIT_SCORE) < 0;
    }
    
    private boolean hasExcessiveDebtToIncomeRatio(LoanApplication application) {
        BigDecimal ratio = application.calculateDebtToIncomeRatio();
        return ratio.compareTo(MAXIMUM_DEBT_TO_INCOME_RATIO) > 0;
    }
    
    private boolean lacksAdequateCollateral(LoanApplication application) {
        BigDecimal collateralValue = application.getCollateral().getCurrentValue();
        BigDecimal loanAmount = application.getRequestedAmount();
        BigDecimal requiredRatio = new BigDecimal("0.8"); // 80% LTV
        
        return collateralValue.multiply(requiredRatio).compareTo(loanAmount) < 0;
    }
}

public class BankAccountService {
    
    public TransferResult transfer(String fromAccountId, String toAccountId, BigDecimal amount) {
        // 參數驗證
        if (fromAccountId == null || fromAccountId.trim().isEmpty()) {
            throw new IllegalArgumentException("來源帳號不可為空");
        }
        
        if (toAccountId == null || toAccountId.trim().isEmpty()) {
            throw new IllegalArgumentException("目標帳號不可為空");
        }
        
        if (amount == null || amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new IllegalArgumentException("轉帳金額必須大於零");
        }
        
        if (fromAccountId.equals(toAccountId)) {
            throw new IllegalArgumentException("來源與目標帳號不可相同");
        }
        
        // 業務邏輯
        Account fromAccount = accountRepository.findById(fromAccountId)
            .orElseThrow(() -> new AccountNotFoundException("找不到來源帳號: " + fromAccountId));
            
        Account toAccount = accountRepository.findById(toAccountId)
            .orElseThrow(() -> new AccountNotFoundException("找不到目標帳號: " + toAccountId));
        
        if (fromAccount.isBlocked()) {
            return TransferResult.failure("來源帳號已被凍結");
        }
        
        if (toAccount.isBlocked()) {
            return TransferResult.failure("目標帳號已被凍結");
        }
        
        if (!fromAccount.hasSufficientBalance(amount)) {
            return TransferResult.failure("餘額不足");
        }
        
        // 執行轉帳
        return executeTransfer(fromAccount, toAccount, amount);
    }
}

@Service
public class ProductService {
    
    private final ProductRepository productRepository;
    private final CacheManager cacheManager;
    
    @Cacheable(value = "products", key = "#productId")
    public Product getProduct(String productId) {
        return productRepository.findById(productId)
            .orElseThrow(() -> new ProductNotFoundException(productId));
    }
    
    @CacheEvict(value = "products", key = "#product.id")
    public Product updateProduct(Product product) {
        return productRepository.save(product);
    }
    
    // 批次查詢避免 N+1 問題
    public List<Product> getProducts(List<String> productIds) {
        // 先從快取取得
        Map<String, Product> cachedProducts = new HashMap<>();
        List<String> uncachedIds = new ArrayList<>();
        
        for (String id : productIds) {
            Product cached = cacheManager.getCache("products").get(id, Product.class);
            if (cached != null) {
                cachedProducts.put(id, cached);
            } else {
                uncachedIds.add(id);
            }
        }
        
        // 批次查詢未快取的資料
        List<Product> uncachedProducts = productRepository.findByIdIn(uncachedIds);
        
        // 加入快取
        uncachedProducts.forEach(product -> 
            cacheManager.getCache("products").put(product.getId(), product));
        
        // 合併結果
        List<Product> results = new ArrayList<>(cachedProducts.values());
        results.addAll(uncachedProducts);
        
        return results;
    }
}

@RestController
public class UserController {
    
    private final UserService userService;
    private final SecurityService securityService;
    
    @PostMapping("/users")
    @PreAuthorize("hasRole('ADMIN')")
    public ResponseEntity<UserResponse> createUser(@Valid @RequestBody CreateUserRequest request) {
        // 輸入驗證
        ValidationResult validation = validateRequest(request);
        if (!validation.isValid()) {
            return ResponseEntity.badRequest()
                .body(new UserResponse(false, validation.getErrors()));
        }
        
        // 敏感資料處理
        String sanitizedEmail = securityService.sanitizeInput(request.getEmail());
        String hashedPassword = securityService.hashPassword(request.getPassword());
        
        try {
            User user = userService.createUser(request.getName(), sanitizedEmail, hashedPassword);
            
            // 不回傳敏感資訊
            UserResponse response = new UserResponse(user.getId(), user.getName(), user.getEmail());
            
            // 記錄安全事件
            securityService.logUserCreation(user.getId(), getCurrentUser().getId());
            
            return ResponseEntity.ok(response);
            
        } catch (DuplicateEmailException e) {
            // 不洩漏系統內部資訊
            return ResponseEntity.badRequest()
                .body(new UserResponse(false, "電子郵件已被使用"));
        } catch (Exception e) {
            // 記錄詳細錯誤，但只回傳一般性訊息
            log.error("Failed to create user", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(new UserResponse(false, "系統暫時無法處理請求"));
        }
    }
    
    private ValidationResult validateRequest(CreateUserRequest request) {
        List<String> errors = new ArrayList<>();
        
        if (!EmailValidator.isValid(request.getEmail())) {
            errors.add("電子郵件格式不正確");
        }
        
        if (!PasswordPolicy.meetsRequirements(request.getPassword())) {
            errors.add("密碼不符合安全性要求");
        }
        
        if (containsSqlInjectionPatterns(request.getName())) {
            errors.add("名稱包含不允許的字元");
        }
        
        return new ValidationResult(errors.isEmpty(), errors);
    }
}

public class 初級開發者能力 {
    
    // 1. 基礎概念理解
    public void 理解物件導向概念() {
        /*
         * ✓ 封裝 (Encapsulation)
         * ✓ 繼承 (Inheritance)  
         * ✓ 多型 (Polymorphism)
         * ✓ 抽象 (Abstraction)
         */
    }
    
    // 2. UML 圖形繪製
    public void 繪製UML圖形() {
        /*
         * ✓ 類別圖設計
         * ✓ Use Case 圖分析
         * ✓ 循序圖建模
         * ✓ 狀態圖描述
         */
    }
    
    // 3. 程式碼實作
    public void 實作設計程式碼() {
        /*
         * ✓ 將 UML 轉換為程式碼
         * ✓ 應用設計模式
         * ✓ 遵循 SOLID 原則
         * ✓ 編寫可維護的程式碼
         */
    }
}

🎯 軟體設計認證：
   - OCUP (Object Management Group UML Certification)
   - AWS/Azure/GCP 雲端架構師認證
   - TOGAF 企業架構認證

🎯 敏捷開發認證：
   - Certified ScrumMaster (CSM)
   - SAFe Architect Certification
   - PMI Agile Certified Practitioner (PMI-ACP)

🎯 技術專精認證：
   - Spring Professional Certification
   - Oracle Java Certification
   - Microsoft Azure Developer Certification

🎓 碩士學位：
   - 資訊工程/資訊科學碩士
   - 軟體工程碩士  
   - 資訊管理碩士

🎓 專業證照：
   - 資訊技師執照
   - PMP 專案管理師
   - CISSP 資訊安全師

public class 專案經驗累積 {
    
    public void 開源專案貢獻() {
        /*
         * 1. 選擇知名開源專案參與
         * 2. 從文件翻譯、Bug 修復開始
         * 3. 逐步參與功能開發
         * 4. 學習大型專案的架構設計
         */
    }
    
    public void 個人專案練習() {
        /*
         * 1. 設計完整的系統專案
         * 2. 應用學到的 OOAD 技術
         * 3. 建立技術部落格分享心得
         * 4. 參與技術社群交流
         */
    }
    
    public void 工作專案提升() {
        /*
         * 1. 主動承擔設計責任
         * 2. 推廣 OOAD 最佳實務
         * 3. 指導團隊成員
         * 4. 建立技術標準文件
         */
    }
}

📚 必讀經典：
   1. "Design Patterns" by Gang of Four
      - 設計模式的經典之作
      - 23 種基本設計模式詳解

   2. "Clean Code" by Robert C. Martin
      - 程式碼品質的黃金標準
      - 實用的編程原則和技巧

   3. "Refactoring" by Martin Fowler
      - 程式碼重構的權威指南
      - 系統性的改善程式碼方法

   4. "Domain-Driven Design" by Eric Evans
      - 領域驅動設計的開創性著作
      - 複雜軟體系統的建模方法

📚 進階閱讀：
   1. "Software Architecture in Practice" by Bass, Clements, Kazman
      - 軟體架構設計的完整指南
      - 品質屬性與架構模式

   2. "Building Microservices" by Sam Newman
      - 微服務架構設計實務
      - 分散式系統的挑戰與解決方案

   3. "System Design Interview" by Alex Xu
      - 大規模系統設計面試準備
      - 實際案例分析與解決方案

   4. "The Pragmatic Programmer" by Andrew Hunt & David Thomas
      - 程式設計師的職業素養
      - 實用的軟體開發哲學

🌐 線上課程：
   - MIT OpenCourseWare: 軟體工程課程
   - Stanford CS 106A/106B: 程式設計基礎
   - Berkeley CS 61B: 資料結構與演算法
   - CMU 15-213: 計算機系統概論

🎥 影片教學：
   - YouTube: Derek Banas 設計模式系列
   - Coursera: 軟體設計與架構專業課程
   - edX: 軟體工程微學位課程
   - Udacity: 軟體架構與設計奈米學位

💰 專業培訓：
   - Pluralsight: 企業級技術培訓
   - LinkedIn Learning: 職業技能發展
   - Udemy: 實務導向的技術課程
   - O'Reilly Learning: 技術書籍與影片庫

🏫 企業培訓：
   - Microsoft Learn: Azure 和 .NET 技術
   - Google Cloud Training: 雲端技術培訓
   - AWS Training: 雲端架構認證課程
   - Oracle University: Java 和資料庫技術

👥 線上社群：
   - Stack Overflow: 程式設計問答平台
   - GitHub: 開源專案協作平台  
   - Reddit: r/programming, r/softwarearchitecture
   - Discord: 各種程式語言和框架社群

🏢 專業組織：
   - ACM (Association for Computing Machinery)
   - IEEE Computer Society
   - Object Management Group (OMG)
   - Agile Alliance

📰 技術媒體：
   - InfoQ: 企業軟體開發新聞
   - High Scalability: 系統架構案例分析
   - ThoughtWorks Technology Radar: 技術趨勢報告
   - Martin Fowler's Bliki: 軟體設計思考

📝 個人部落格：
   - Uncle Bob (Robert C. Martin): 軟體工藝
   - Martin Fowler: 企業應用架構
   - Joel Spolsky: 軟體管理與設計
   - Jeff Atwood: Coding Horror

🛠️ UML 建模工具：
   - Visual Paradigm: 企業級建模平台
   - Enterprise Architect: 全功能建模工具
   - PlantUML: 文字式 UML 描述
   - Draw.io: 免費線上圖形工具

🔧 程式碼分析工具：
   - SonarQube: 程式碼品質分析
   - SpotBugs: Java 靜態分析
   - Checkstyle: 程式碼風格檢查
   - PMD: 程式碼缺陷檢測

// Spring Boot 生態系統
public class SpringBootLearning {
    /*
     * 學習路徑：
     * 1. Spring Core (IoC/DI)
     * 2. Spring Boot (自動配置)
     * 3. Spring Data (資料存取)
     * 4. Spring Security (安全性)
     * 5. Spring Cloud (微服務)
     */
}

// 前端技術整合
public class FullStackDevelopment {
    /*
     * 現代全端開發：
     * 1. React/Vue.js (前端框架)
     * 2. RESTful API 設計
     * 3. GraphQL (查詢語言)
     * 4. WebSocket (即時通訊)
     */
}

📊 技能評估 (1-5 分)：

核心技術技能：
□ 物件導向設計 [___/5]
□ 設計模式應用 [___/5]  
□ 系統架構設計 [___/5]
□ 資料庫設計 [___/5]
□ 網路與安全 [___/5]

程式語言熟練度：
□ Java/C#/.NET [___/5]
□ JavaScript/TypeScript [___/5]
□ Python [___/5]
□ SQL [___/5]

框架與工具：
□ Spring/Spring Boot [___/5]
□ React/Vue/Angular [___/5]
□ Docker/Kubernetes [___/5]
□ Git/CI/CD [___/5]

軟技能：
□ 團隊協作 [___/5]
□ 技術溝通 [___/5]
□ 問題解決 [___/5]
□ 學習能力 [___/5]

public class 年度學習計畫2024 {
    
    public void Q1目標() {
        /*
         * 技術深化：
         * - 完成 Spring Boot 高級特性學習
         * - 取得 AWS Solutions Architect 認證
         * - 參與 1 個開源專案貢獻
         */
    }
    
    public void Q2目標() {
        /*
         * 架構能力：
         * - 學習微服務架構設計
         * - 實作完整的分散式系統專案
         * - 發表技術分享或部落格文章
         */
    }
    
    public void Q3目標() {
        /*
         * 領導力發展：
         * - 帶領團隊完成重要專案
         * - 參加技術會議或研討會
         * - 建立技術指導關係 (Mentorship)
         */
    }
    
    public void Q4目標() {
        /*
         * 職涯規劃：
         * - 總結年度成果和學習心得
         * - 規劃下一年度發展方向
         * - 更新履歷和作品集
         */
    }
}

public class 個人品牌建立 {
    
    public void 內容創作() {
        /*
         * 1. 技術部落格：
         *    - 分享學習心得和實務經驗
         *    - 深度技術文章和案例分析
         *    - SEO 優化提高可見度
         * 
         * 2. 開源貢獻：
         *    - 維護個人開源專案
         *    - 貢獻知名開源專案
         *    - 建立技術聲譽
         */
    }
    
    public void 社群參與() {
        /*
         * 1. 技術分享：
         *    - 參加技術聚會和會議
         *    - 擔任技術演講嘉賓
         *    - 組織技術讀書會
         * 
         * 2. 線上互動：
         *    - Stack Overflow 回答問題
         *    - GitHub 活躍貢獻
         *    - LinkedIn 專業網絡建立
         */
    }
    
    public void 專業認證() {
        /*
         * 1. 技術認證：
         *    - 雲端平台認證
         *    - 框架專業認證
         *    - 軟體架構認證
         * 
         * 2. 軟技能認證：
         *    - 專案管理 PMP
         *    - 敏捷開發 Scrum Master
         *    - 領導力培訓證書
         */
    }
}

public class 技術演進趨勢 {
    
    /*
     * 軟體開發的永恆真理：
     * 
     * 1. "唯一不變的就是變化"
     *    - 新技術不斷出現
     *    - 最佳實務持續演進
     *    - 業務需求日益複雜
     * 
     * 2. "基礎知識的重要性"
     *    - OOAD 原則歷久彌新
     *    - 設計模式跨語言通用
     *    - 系統思維永遠有效
     * 
     * 3. "終身學習的必要性"
     *    - 保持技術競爭力
     *    - 適應行業變化
     *    - 實現職涯發展
     */
}

public class 新手開發者建議 {
    
    public void 技術基礎建立() {
        /*
         * 重要提醒：
         * 
         * 1. 不要急於追求新技術
         *    - 先紮實基礎概念
         *    - 深入理解核心原理
         *    - 避免技術棧過於分散
         * 
         * 2. 重視程式碼品質
         *    - 遵循編碼規範
         *    - 實踐 SOLID 原則
         *    - 培養重構習慣
         * 
         * 3. 培養系統思維
         *    - 理解業務需求
         *    - 考慮系統整體性
         *    - 關注非功能性需求
         */
    }
    
    public void 職場適應建議() {
        /*
         * 軟技能發展：
         * 
         * 1. 主動溝通
         *    - 不懂就問，不要假裝懂
         *    - 定期與主管同步進度
         *    - 積極參與團隊討論
         * 
         * 2. 承擔責任
         *    - 為自己的程式碼負責
         *    - 主動承擔適當的挑戰
         *    - 從錯誤中學習成長
         * 
         * 3. 團隊合作
         *    - 尊重不同的觀點
         *    - 分享知識和經驗
         *    - 協助團隊成員解決問題
         */
    }
}

public class 永恆的核心能力 {
    /*
     * 無論技術如何變化，以下能力始終重要：
     * 
     * 1. 抽象思維能力
     *    - 將複雜問題簡化
     *    - 識別共同模式
     *    - 設計通用解決方案
     * 
     * 2. 系統性思考
     *    - 理解元件間的關係
     *    - 考慮變更的影響範圍
     *    - 平衡各種設計權衡
     * 
     * 3. 溝通協作能力
     *    - 清楚表達技術概念
     *    - 理解業務需求
     *    - 有效的團隊合作
     * 
     * 4. 持續學習能力
     *    - 快速適應新技術
     *    - 自主學習新知識
     *    - 保持好奇心和熱情
     */
}

□ 我能清楚解釋封裝(Encapsulation)的概念和重要性
□ 我理解繼承(Inheritance)的適用場景和注意事項  
□ 我掌握多型(Polymorphism)的實作方法和應用時機
□ 我能運用抽象(Abstraction)來簡化複雜系統設計
□ 我了解物件導向與程序導向的根本差異

□ 單一職責原則(SRP): 我能識別並重構違反此原則的程式碼
□ 開閉原則(OCP): 我能設計可擴展但不需修改的系統結構
□ 里氏替換原則(LSP): 我理解正確的繼承關係設計
□ 介面隔離原則(ISP): 我能設計精簡且專用的介面
□ 依賴反轉原則(DIP): 我會使用依賴注入來降低耦合度

□ 類別圖: 我能準確繪製包含屬性、方法和關係的類別圖
□ 物件圖: 我能展示特定時間點的物件實例狀態
□ 組件圖: 我能描述系統的模組化結構和依賴關係
□ 部署圖: 我能展示軟體組件在硬體環境中的部署情況

□ Use Case 圖: 我能分析需求並繪製完整的使用案例圖
□ 活動圖: 我能描述複雜的業務流程和決策邏輯
□ 狀態機圖: 我能建模物件的生命週期和狀態轉換
□ 循序圖: 我能展示物件間的時序互動和訊息傳遞

□ 我能與利害關係人有效溝通，蒐集完整的需求資訊
□ 我會使用 Use Case 技術來組織和管理需求
□ 我能識別功能性需求和非功能性需求的差異
□ 我會進行需求優先級排序和變更管理
□ 我能將業務需求轉換為技術規格說明

□ 我能運用分層架構原則設計系統結構
□ 我會選擇合適的設計模式解決特定問題
□ 我能設計資料庫結構和資料存取層
□ 我會考慮系統的可擴展性和可維護性
□ 我能進行技術風險評估和解決方案設計

// 自我檢核: 我能完成以下程式設計任務

public class 程式設計能力檢核 {
    
    /*
     * 基礎程式設計能力:
     */
    
    // □ 設計並實作一個完整的類別，包含適當的封裝
    public void 設計封裝類別() {
        // 私有屬性、公開方法、資料驗證
    }
    
    // □ 正確使用繼承建立類別階層關係
    public void 實作繼承關係() {
        // 基礎類別、衍生類別、方法覆寫
    }
    
    // □ 實作多型和介面，展示抽象設計能力
    public void 應用多型設計() {
        // 介面定義、多種實作、動態綁定
    }
    
    // □ 應用設計模式解決常見的設計問題
    public void 套用設計模式() {
        // 工廠模式、觀察者模式、策略模式等
    }
    
    // □ 撰寫單元測試驗證程式碼正確性
    public void 編寫單元測試() {
        // JUnit 測試、測試覆蓋率、邊界條件測試
    }
}

選擇以下其中一個主題，完成完整的分析設計:

□ 線上書店管理系統
  - 會員管理、商品目錄、訂單處理、庫存管理
  - 涵蓋前台購物網站和後台管理系統

□ 學生選課系統  
  - 學生註冊、課程管理、選課流程、成績記錄
  - 包含學生、教師、管理員三種角色

□ 專案管理系統
  - 專案建立、任務分配、進度追蹤、資源管理
  - 支援團隊協作和專案報表功能

□ 醫院掛號系統
  - 病患資料、醫師排班、掛號預約、病歷管理
  - 考慮醫療流程的特殊需求

專案交付成果:
□ 需求分析文件 (Use Case 圖 + 使用案例說明)
□ 系統設計文件 (類別圖 + 循序圖 + 活動圖)
□ 程式碼實作 (核心功能的 Java 實作)
□ 測試計畫 (單元測試 + 整合測試)
□ 部署說明 (系統安裝與設定指南)

情境描述:
一家新創公司要開發電商平台，從初期的單體應用
逐步演進為大規模的分散式系統。

階段性任務:

□ 第一階段: 單體應用設計
  - 分析初期業務需求
  - 設計單體架構的類別圖
  - 識別核心業務流程

□ 第二階段: 服務拆分分析
  - 識別服務邊界和職責
  - 設計微服務架構
  - 處理分散式系統的挑戰

□ 第三階段: 系統優化設計
  - 效能瓶頸分析
  - 可擴展性設計
  - 維運監控策略

學習目標:
□ 理解系統架構演進的決策因素
□ 掌握不同規模系統的設計考量
□ 學會在實務限制下做出設計權衡

public class 技術決策能力評估 {
    
    /*
     * 情境題: 為新專案選擇技術棧
     * 
     * 專案需求:
     * - 預期用戶數: 10萬活躍用戶
     * - 響應時間要求: < 2秒
     * - 可用性要求: 99.9%
     * - 開發團隊: 5人，Java背景
     * - 上線時程: 6個月
     */
    
    // □ 我能分析業務需求對技術架構的影響
    public void 需求分析() {
        /*
         * 考慮因素:
         * - 功能性需求 vs 非功能性需求
         * - 現有團隊技能 vs 學習成本
         * - 開發效率 vs 長期維護性
         * - 預算限制 vs 技術理想性
         */
    }
    
    // □ 我能評估不同技術方案的優缺點
    public void 方案比較() {
        /*
         * 比較標準:
         * - 開發生產力
         * - 系統效能
         * - 可擴展性
         * - 技術風險
         * - 社群支援
         */
    }
    
    // □ 我能制定技術實作計畫
    public void 實作規劃() {
        /*
         * 規劃內容:
         * - 技術框架選擇
         * - 開發階段劃分
         * - 風險控制措施
         * - 團隊培訓計畫
         */
    }
}

技術技能缺口:
□ 分散式系統設計經驗不足
□ 大數據處理技術需要學習
□ 雲端服務架構不夠熟悉
□ 資訊安全最佳實務需要加強
□ DevOps 工具鏈操作不熟練

軟技能缺口:
□ 跨部門溝通技巧需要提升
□ 技術演講和簡報能力待改善
□ 專案管理經驗需要累積
□ 團隊領導能力需要培養
□ 商業思維和產品意識不足

public class 改善行動計畫 {
    
    // □ 設定明確的學習目標和時程
    public void 制定學習目標() {
        /*
         * SMART 目標設定:
         * - Specific: 具體明確的學習內容
         * - Measurable: 可衡量的成果指標
         * - Achievable: 可實現的目標水準
         * - Relevant: 與職涯發展相關
         * - Time-bound: 明確的完成期限
         */
    }
    
    // □ 建立定期的學習和實作習慣
    public void 建立學習習慣() {
        /*
         * 學習計畫:
         * - 每週固定時間投入學習
         * - 理論學習與實作練習並重
         * - 定期檢視進度和調整方向
         * - 尋找學習夥伴和指導者
         */
    }
    
    // □ 設定可衡量的進步指標
    public void 設定進步指標() {
        /*
         * 評估指標:
         * - 完成的線上課程數量
         * - 實作的專案作品質量
         * - 獲得的技術認證
         * - 工作中應用新技能的成果
         */
    }
}

月份: ______

本月學習成果:
□ 完成的課程/書籍: _______________
□ 實作的專案/練習: _______________  
□ 參與的技術活動: _______________
□ 獲得的回饋建議: _______________

技能提升評估:
□ 新掌握的技術: _________________
□ 改善的技能領域: _______________
□ 仍需加強的部分: _______________

下月學習計畫:
□ 優先學習主題: _________________
□ 計畫參與活動: _________________
□ 預期達成目標: _________________

□ 完成 OCUP Fundamental Level 認證
□ 取得 Oracle Java SE 11 Certification  
□ 獲得 AWS Cloud Practitioner 認證
□ 完成 Spring Professional 認證課程
□ 參加至少 2 場技術研討會或工作坊

□ 完成一個完整的個人專案作品集
□ 在技術部落格發表至少 5 篇文章
□ 貢獻至少 1 個開源專案
□ 在公司內部進行技術分享
□ 指導至少 1 位初級開發者

□ 升任中級軟體工程師或相當職位
□ 成為團隊中的技術領導者
□ 獲得進階技術認證 (OCUP Intermediate)
□ 建立個人技術品牌和影響力
□ 參與重要專案的架構設計決策

□ 成為軟體架構師或技術主管
□ 具備跨領域的技術整合能力
□ 成為公司或社群的技術專家
□ 獲得高階技術認證和專業肯定
□ 培養下一代的軟體開發人才

□ 物件導向分析與設計的完整概念體系
□ UML 建模語言的標準語法和應用技巧  
□ SOLID 設計原則和常用設計模式
□ 從需求分析到程式實作的完整流程
□ 軟體品質控制和最佳實務應用

□ 獨立完成中小型系統的分析設計
□ 使用 UML 工具進行專業建模
□ 撰寫高品質、可維護的 Java 程式碼
□ 進行有效的程式碼審查和重構
□ 與團隊成員進行技術溝通協作

□ 自主學習新技術和框架的能力
□ 分析技術趨勢和做出技術決策
□ 建立個人學習計畫和執行能力
□ 參與技術社群和知識分享
□ 規劃職涯發展和技能提升路徑

題目範例：
下列哪一個圖形最適合用來展示系統的部署架構？

A) 類別圖 (Class Diagram)
B) 循序圖 (Sequence Diagram)  
C) 部署圖 (Deployment Diagram)
D) 活動圖 (Activity Diagram)

正確答案：C
解析：部署圖專門用來展示軟體組件在硬體節點上的物理部署情況。

題目範例：
在類別圖中，-firstName: String 表示什麼？

A) firstName 是公開的靜態屬性
B) firstName 是私有的字串屬性
C) firstName 是受保護的方法
D) firstName 是套件層級的常數

正確答案：B
解析："-" 表示私有可見性，": String" 表示字串類型的屬性。

題目範例：
在 UML 中，實心菱形箭頭表示什麼關係？

A) 關聯 (Association)
B) 聚合 (Aggregation)
C) 組合 (Composition)
D) 繼承 (Inheritance)

正確答案：C
解析：實心菱形表示組合關係，是一種強擁有關係。

A) 提供程式設計語言
B) 標準化軟體建模語言
C) 取代程式碼文件
D) 簡化資料庫設計

正確答案：B
解析：UML (Unified Modeling Language) 的主要目的是提供標準化的軟體建模語言，
讓開發團隊能夠用統一的圖形語言來描述、視覺化和記錄軟體系統。

A) 類別圖 (Class Diagram)
B) 組件圖 (Component Diagram)
C) 活動圖 (Activity Diagram)
D) 物件圖 (Object Diagram)

正確答案：C
解析：活動圖是行為圖，用來描述系統的動態行為和工作流程。
結構圖包括類別圖、物件圖、組件圖、部署圖等。

A) +calculateArea(): double
B) +calculateArea(): double {abstract}
C) +calculateArea(): double*
D) #{abstract} calculateArea(): double

正確答案：B 或 C (根據不同的 UML 工具表示法)
解析：抽象方法可以用斜體字、{abstract} 標籤或星號 (*) 來表示。

A) 部分可以獨立於整體存在
B) 整體銷毀時，部分也會銷毀
C) 部分可以同時屬於多個整體
D) 整體與部分之間沒有生命週期依賴

正確答案：B
解析：組合關係是強擁有關係，整體銷毀時部分也必須銷毀，
部分不能獨立於整體存在。

A) 可選的功能擴展
B) 必須執行的子功能
C) 行為者之間的關係
D) 系統的變體功能

正確答案：B
解析：include 關係表示基本 Use Case 必須包含的子功能，
每次執行基本 Use Case 時都會執行被包含的 Use Case。

A) 事件/動作[條件]
B) [條件]事件/動作
C) 事件[條件]/動作
D) 動作/事件[條件]

正確答案：C
解析：狀態轉換的完整格式是「事件[守衛條件]/效果動作」，
其中守衛條件和效果動作都是可選的。

// 將抽象概念轉換為具體程式碼
public class 學習範例 {
    
    // 將 UML 類別圖轉換為 Java 程式碼
    public void 類別圖轉程式碼() {
        /*
         * UML: Customer -----> Order
         * 意思: Customer 類別關聯到 Order 類別
         */
    }
    
    // 將程式碼關係轉換為 UML 圖形
    public void 程式碼轉UML() {
        /*
         * Java: class Dog extends Animal
         * UML: Dog --|> Animal (繼承關係)
         */
    }
}

正面: 在類別圖中，空心菱形表示什麼關係？
背面: 聚合關係 (Aggregation)
      - 整體與部分的鬆散關係
      - 部分可以獨立於整體存在
      - 例如：部門 ◇——— 員工

// 練習題：為線上書店系統設計類別圖
public class BookstoreExercise {
    
    /*
     * 要求：設計包含以下實體的類別圖
     * - Customer (顧客)
     * - Book (書籍)
     * - Order (訂單)
     * - OrderItem (訂單項目)
     * - ShoppingCart (購物車)
     * 
     * 考慮：
     * 1. 類別之間的關係類型
     * 2. 屬性的可見性
     * 3. 方法的設計
     * 4. 多重性 (Multiplicity)
     */
}

📚 基礎入門：
   - "UML Distilled" by Martin Fowler
   - "Learning UML 2.0" by Russ Miles & Kim Hamilton

📚 進階應用：
   - "UML 2 and the Unified Process" by Jim Arlow & Ila Neustadt
   - "Applying UML and Patterns" by Craig Larman

📚 考試準備：
   - "OCUP Certification Guide" by Tim Weilkiens
   - "UML 2.0 in Action" by Patrick Lenca

🆓 免費工具：
   - PlantUML: 文字式 UML 建模
   - Draw.io: 線上圖形繪製工具
   - StarUML: 開源 UML 工具

💰 商業工具：
   - Visual Paradigm: 專業 UML 建模平台
   - Enterprise Architect: 企業級建模工具
   - MagicDraw: NoMagic 的專業工具

🎯 線上練習：
   - UML Quiz 網站
   - OCUP 模擬考試平台
   - Stack Overflow UML 標籤

👥 社群資源：
   - LinkedIn UML 專業群組
   - Reddit r/UML 社群
   - UML 相關的 Discord 伺服器

public class 學習計畫 {
    
    private void 每日學習例程() {
        /*
         * 1. 早晨 30 分鐘：複習前一天學習內容
         * 2. 午休 15 分鐘：完成 10-15 道練習題
         * 3. 晚上 45 分鐘：學習新概念或深入研讀
         * 4. 睡前 15 分鐘：整理學習筆記
         */
    }
    
    private void 週末加強練習() {
        /*
         * 1. 週六上午：完整模擬考試
         * 2. 週六下午：分析錯題和弱點
         * 3. 週日上午：針對性加強練習
         * 4. 週日下午：整理週學習成果
         */
    }
}

📖 設計模式四人幫 (Gang of Four)
   "Design Patterns: Elements of Reusable Object-Oriented Software"
   - 23 種經典設計模式
   - 物件導向設計的核心理念
   - 每個軟體工程師的必讀書籍

📖 Head First 設計模式
   "Head First Design Patterns"
   - 生動有趣的學習方式
   - 豐富的圖解和範例
   - 適合初學者建立設計模式概念

// 推薦的 Java 設計模式書籍
public class 設計模式書籍推薦 {
    
    private List<Book> 推薦書單 = Arrays.asList(
        new Book("Effective Java", "Joshua Bloch"),
        new Book("Clean Code", "Robert C. Martin"),
        new Book("Refactoring", "Martin Fowler"),
        new Book("Domain-Driven Design", "Eric Evans")
    );
    
    // 每本書的學習重點
    public void 學習重點整理() {
        /*
         * Effective Java: Java 最佳實務和常見陷阱
         * Clean Code: 寫出可讀性和可維護性高的程式碼
         * Refactoring: 系統性地改善既有程式碼
         * DDD: 複雜領域的建模方法
         */
    }
}

🏛️ 國際標準組織規範：
   - ISO/IEC 19501: UML 國際標準
   - ISO/IEC 19503: UML Profile 標準
   - ISO/IEC 19505: Object Constraint Language (OCL)
   - ISO/IEC 25010: 軟體品質模型

🎓 線上學習平台：
   - Coursera: 大學級的 OOAD 課程
   - edX: MIT、史丹佛等頂尖大學課程
   - Udemy: 實務導向的 UML 和設計模式課程
   - Pluralsight: 專業技術培訓平台
   - LinkedIn Learning: 職場技能提升課程

public class 專業社群資源 {
    
    private List<Community> 推薦社群 = Arrays.asList(
        new Community("DZone", "軟體開發文章和教學"),
        new Community("InfoQ", "企業軟體開發新聞"),
        new Community("CodeProject", "程式設計教學和範例"),
        new Community("Medium", "技術部落格和經驗分享")
    );
    
    // 社群參與建議
    public void 社群參與策略() {
        /*
         * 1. 主動提問：遇到問題時勇於發問
         * 2. 分享經驗：將學習心得分享給社群
         * 3. 協助他人：回答其他人的問題
         * 4. 持續關注：定期關注最新討論和趨勢
         */
    }
}

public class 學習網絡建立 {
    
    // 1. 建立學習計畫
    public void 制定學習計畫() {
        /*
         * 短期目標 (3個月):
         * - 完成 UML 基礎認證
         * - 參與 1-2 個開源專案
         * - 建立個人技術部落格
         * 
         * 中期目標 (1年):
         * - 取得進階 UML 認證
         * - 在團隊中推廣 OOAD 實務
         * - 參加技術會議和研討會
         * 
         * 長期目標 (3年):
         * - 成為技術領導者
         * - 貢獻開源 UML 工具
         * - 培養後進開發者
         */
    }
    
    // 2. 知識分享機制
    public void 建立分享機制() {
        /*
         * 內部分享:
         * - 定期團隊技術分享
         * - 建立知識庫和最佳實務文件
         * - 舉辦內部讀書會
         * 
         * 外部分享:
         * - 撰寫技術部落格文章
         * - 參與技術社群討論
         * - 在會議中發表演講
         */
    }
}

public class 學習成效評估 {
    
    // 技能評估矩陣
    public enum 技能等級 {
        初學者(1, "了解基本概念"),
        進階者(2, "能夠獨立應用"),
        熟練者(3, "能夠指導他人"),
        專家級(4, "能夠創新改進");
        
        private int level;
        private String description;
    }
    
    // 評估檢查清單
    public void 進行自我評估() {
        Map<String, 技能等級> 技能評估 = new HashMap<>();
        
        // UML 建模能力
        技能評估.put("類別圖設計", 技能等級.熟練者);
        技能評估.put("循序圖建模", 技能等級.進階者);
        技能評估.put("狀態圖描述", 技能等級.進階者);
        
        // 程式實作能力
        技能評估.put("設計模式應用", 技能等級.進階者);
        技能評估.put("SOLID 原則實踐", 技能等級.熟練者);
        技能評估.put("程式碼重構", 技能等級.進階者);
        
        // 分析結果並制定改進計畫
        分析評估結果(技能評估);
    }
    
    private void 分析評估結果(Map<String, 技能等級> 評估結果) {
        // 識別強項和弱項
        // 制定針對性的學習計畫
        // 設定明確的改進目標
    }
}

public class UseCaseCheckList {
    
    // Use Case 完整性檢查
    public boolean 檢查UseCaseComplete() {
        return 檢查項目清單(Arrays.asList(
            "每個 Use Case 都有明確的主要成功情境",
            "已識別所有替代流程和例外情況",
            "明確定義每個 Use Case 的前置條件",
            "明確定義每個 Use Case 的後置條件",
            "指定每個 Use Case 的主要參與者",
            "Use Case 之間的關係已明確定義"
        ));
    }
    
    // Use Case 品質檢查
    public boolean 檢查UseCaseQuality() {
        return 檢查項目清單(Arrays.asList(
            "Use Case 名稱清楚表達目標",
            "描述採用使用者觀點",
            "避免技術實作細節",
            "情境描述完整且可理解",
            "已驗證 Use Case 的正確性"
        ));
    }
}

public class ClassDiagramCheckList {
    
    // 類別定義檢查
    public boolean 檢查類別定義() {
        return 檢查項目清單(Arrays.asList(
            "類別名稱遵循命名慣例",
            "類別責任單一且明確",
            "屬性具有適當的可見性",
            "方法簽章正確且完整",
            "類別之間的關係正確表達"
        ));
    }
    
    // 關係檢查
    public boolean 檢查類別關係() {
        return 檢查項目清單(Arrays.asList(
            "繼承關係符合 'is-a' 關係",
            "組合關係符合 'part-of' 關係",
            "關聯關係具有正確的多重性",
            "依賴關係最小化",
            "避免循環依賴"
        ));
    }
    
    // 設計品質檢查
    public boolean 檢查設計品質() {
        return 檢查項目清單(Arrays.asList(
            "類別數量適中 (不過多不過少)",
            "繼承層次深度合理 (建議不超過 6 層)",
            "類別耦合度低",
            "介面設計合理",
            "抽象程度適當"
        ));
    }
}

專案結構檢查清單：
📁 src/
  📁 main/
    📁 java/
      📁 com/company/project/
        📁 controller/     ✅ 控制層類別
        📁 service/        ✅ 業務邏輯層
        📁 repository/     ✅ 資料存取層
        📁 model/          ✅ 領域模型
        📁 dto/            ✅ 資料傳輸物件
        📁 config/         ✅ 配置類別
        📁 util/           ✅ 工具類別
    📁 resources/          ✅ 配置檔案和資源
  📁 test/
    📁 java/              ✅ 單元測試
    📁 resources/         ✅ 測試資源

public class NamingConventionCheck {
    
    // 類別命名檢查
    public boolean 檢查類別命名() {
        /*
         * ✅ 使用 PascalCase (例: UserService)
         * ✅ 名稱具有描述性
         * ✅ 避免縮寫和簡稱
         * ✅ 介面名稱以 I 開頭或 able 結尾
         * ✅ 抽象類別名稱包含 Abstract
         */
        return true;
    }
    
    // 方法命名檢查
    public boolean 檢查方法命名() {
        /*
         * ✅ 使用 camelCase (例: getUserById)
         * ✅ 動詞開頭，表達動作
         * ✅ 布林方法以 is/has/can 開頭
         * ✅ 取得方法以 get 開頭
         * ✅ 設定方法以 set 開頭
         */
        return true;
    }
    
    // 變數命名檢查
    public boolean 檢查變數命名() {
        /*
         * ✅ 使用 camelCase
         * ✅ 常數使用 UPPER_SNAKE_CASE
         * ✅ 名稱具有意義
         * ✅ 避免單字母變數 (除了迴圈計數器)
         * ✅ 布林變數名稱表達是非概念
         */
        return true;
    }
}

public class SOLIDPrincipleCheck {
    
    // S - 單一責任原則檢查
    public boolean checkSingleResponsibility() {
        /*
         * ✅ 每個類別只有一個變更的理由
         * ✅ 類別的方法都圍繞單一主題
         * ✅ 類別大小適中 (建議少於 500 行)
         */
        return true;
    }
    
    // O - 開放封閉原則檢查  
    public boolean checkOpenClosed() {
        /*
         * ✅ 對擴展開放，對修改封閉
         * ✅ 使用抽象和介面進行擴展
         * ✅ 避免修改既有程式碼來新增功能
         */
        return true;
    }
    
    // L - 里氏替換原則檢查
    public boolean checkLiskovSubstitution() {
        /*
         * ✅ 子類別可以替換父類別
         * ✅ 子類別不會破壞父類別的約束
         * ✅ 子類別不會拋出父類別未預期的例外
         */
        return true;
    }
    
    // I - 介面隔離原則檢查
    public boolean checkInterfaceSegregation() {
        /*
         * ✅ 介面方法數量適中
         * ✅ 客戶端不依賴不需要的介面
         * ✅ 介面具有高內聚性
         */
        return true;
    }
    
    // D - 依賴反轉原則檢查
    public boolean checkDependencyInversion() {
        /*
         * ✅ 依賴於抽象而非具體實作
         * ✅ 使用依賴注入
         * ✅ 高層模組不依賴低層模組
         */
        return true;
    }
}

public class FunctionalityCheck {
    
    // 業務邏輯檢查
    public boolean 檢查業務邏輯() {
        return 檢查項目清單(Arrays.asList(
            "業務規則實作正確",
            "計算邏輯準確無誤",
            "條件判斷完整",
            "迴圈邏輯正確",
            "資料驗證充分"
        ));
    }
    
    // 錯誤處理檢查
    public boolean 檢查錯誤處理() {
        return 檢查項目清單(Arrays.asList(
            "例外處理機制完整",
            "錯誤訊息具有意義",
            "系統狀態一致性維護",
            "資源正確釋放",
            "記錄檔記錄適當"
        ));
    }
    
    // 邊界條件檢查
    public boolean 檢查邊界條件() {
        return 檢查項目清單(Arrays.asList(
            "空值處理",
            "邊界值驗證",
            "溢位處理",
            "無效輸入處理",
            "並行存取處理"
        ));
    }
}

public class MaintainabilityCheck {
    
    // 可讀性檢查
    public boolean 檢查可讀性() {
        return 檢查項目清單(Arrays.asList(
            "變數和方法名稱具有意義",
            "程式碼格式化一致",
            "適當的空白和縮排",
            "合理的方法長度 (建議少於 50 行)",
            "適當的註解和文件"
        ));
    }
    
    // 複雜度檢查
    public boolean 檢查複雜度() {
        return 檢查項目清單(Arrays.asList(
            "循環複雜度合理 (建議少於 10)",
            "嵌套層次適中 (建議少於 4 層)",
            "方法參數數量合理 (建議少於 7 個)",
            "類別耦合度低",
            "避免重複程式碼"
        ));
    }
    
    // 設計品質檢查
    public boolean 檢查設計品質() {
        return 檢查項目清單(Arrays.asList(
            "遵循設計模式",
            "介面使用適當",
            "抽象層次合理",
            "模組化設計良好",
            "可測試性高"
        ));
    }
}

public class ProjectHandoverCheck {
    
    // 知識移交檢查
    public boolean 檢查知識移交() {
        return 檢查項目清單(Arrays.asList(
            "技術文件完整且可理解",
            "關鍵開發者進行知識分享",
            "維護團隊接受培訓",
            "程式碼庫存取權限已設定",
            "開發環境設定文件完整"
        ));
    }
    
    // 支援流程檢查
    public boolean 檢查支援流程() {
        return 檢查項目清單(Arrays.asList(
            "問題回報機制建立",
            "緊急聯絡流程定義",
            "維護排程安排",
            "變更管理程序建立",
            "效能監控機制運作"
        ));
    }
    
    // 交付完成確認
    public boolean 確認交付完成() {
        return 檢查項目清單(Arrays.asList(
            "所有功能通過使用者驗收測試",
            "效能需求達標",
            "安全性要求滿足",
            "文件齊全且經過審核",
            "利害關係人正式簽核"
        ));
    }
}