public class Calculator {
    public double calc(double a, double b, String op) {
        if (op.equals("+")) {
            return a + b;
        } else if (op.equals("-")) {
            return a - b;
        } else if (op.equals("*")) {
            return a * b;
        } else if (op.equals("/")) {
            return a / b;
        }
        return 0;
    }
}

public class Calculator {
    public double add(double a, double b) {
        return a + b;
    }
    
    public double subtract(double a, double b) {
        return a - b;
    }
    
    public double multiply(double a, double b) {
        return a * b;
    }
    
    public double divide(double a, double b) {
        if (b == 0) {
            throw new IllegalArgumentException("除數不能為零");
        }
        return a / b;
    }
}

// 壞味道：過長方法
public void processOrder(Order order) {
    // 驗證訂單 (10 行)
    if (order == null) throw new IllegalArgumentException("訂單不能為空");
    if (order.getItems().isEmpty()) throw new IllegalArgumentException("訂單項目不能為空");
    // ... 更多驗證邏輯
    
    // 計算總價 (15 行)
    double total = 0;
    for (OrderItem item : order.getItems()) {
        double itemPrice = item.getPrice() * item.getQuantity();
        if (item.getDiscount() > 0) {
            itemPrice = itemPrice * (1 - item.getDiscount());
        }
        total += itemPrice;
    }
    // ... 更多計算邏輯
    
    // 更新庫存 (20 行)
    // ... 庫存更新邏輯
    
    // 發送通知 (10 行)
    // ... 通知邏輯
}

// 壞味道：過多參數
public void createUser(String firstName, String lastName, String email, 
                      String phone, String address, String city, 
                      String country, int age, boolean isActive) {
    // 實作邏輯
}

// 壞味道：重複程式碼
public double calculateSalary(Employee employee) {
    double baseSalary = employee.getBaseSalary();
    double bonus = baseSalary * 0.1;
    double tax = (baseSalary + bonus) * 0.2;
    return baseSalary + bonus - tax;
}

public double calculatePension(Employee employee) {
    double baseSalary = employee.getBaseSalary();
    double bonus = baseSalary * 0.1;
    double totalIncome = baseSalary + bonus;
    return totalIncome * 0.05;
}

// 壞味道：過大類別
public class UserManager {
    // 使用者 CRUD 操作
    public void createUser() { /* ... */ }
    public void updateUser() { /* ... */ }
    public void deleteUser() { /* ... */ }
    
    // 使用者驗證
    public boolean validateEmail() { /* ... */ }
    public boolean validatePassword() { /* ... */ }
    
    // 郵件發送
    public void sendWelcomeEmail() { /* ... */ }
    public void sendResetPasswordEmail() { /* ... */ }
    
    // 報表生成
    public void generateUserReport() { /* ... */ }
    public void exportUserData() { /* ... */ }
    
    // ... 更多不相關的方法
}

// 使用工具檢測重複程式碼
// PMD 配置範例
<rule ref="category/java/design.xml/CyclomaticComplexity">
    <properties>
        <property name="classReportLevel" value="80"/>
        <property name="methodReportLevel" value="10"/>
    </properties>
</rule>

public class OrderProcessor {
    public String processOrder(String customerName, String customerEmail, 
                              String customerPhone, String customerAddress,
                              String productName, double productPrice, 
                              int quantity, String discountCode) {
        
        // 驗證客戶資訊
        if (customerName == null || customerName.trim().isEmpty()) {
            return "錯誤：客戶姓名不能為空";
        }
        if (customerEmail == null || !customerEmail.contains("@")) {
            return "錯誤：電子郵件格式不正確";
        }
        
        // 計算總價
        double total = productPrice * quantity;
        if (discountCode != null) {
            if (discountCode.equals("SAVE10")) {
                total = total * 0.9;
            } else if (discountCode.equals("SAVE20")) {
                total = total * 0.8;
            }
        }
        
        // 發送確認郵件
        String emailContent = "親愛的 " + customerName + "，您的訂單已確認...";
        // ... 郵件發送邏輯
        
        return "訂單處理成功，總金額：" + total;
    }
}

public void printOwing() {
    printBanner();
    
    // 計算未付金額
    double outstanding = 0.0;
    for (Order order : orders) {
        outstanding += order.getAmount();
    }
    
    // 印出詳細資訊
    System.out.println("客戶名稱：" + name);
    System.out.println("未付金額：" + outstanding);
}

public void printOwing() {
    printBanner();
    double outstanding = calculateOutstanding();
    printDetails(outstanding);
}

private double calculateOutstanding() {
    double outstanding = 0.0;
    for (Order order : orders) {
        outstanding += order.getAmount();
    }
    return outstanding;
}

private void printDetails(double outstanding) {
    System.out.println("客戶名稱：" + name);
    System.out.println("未付金額：" + outstanding);
}

public double calculateTotal(List<Item> items) {
    double t = 0;
    for (Item i : items) {
        double p = i.getPrice();
        double q = i.getQuantity();
        double d = i.getDiscount();
        t += p * q * (1 - d);
    }
    return t;
}

public double calculateTotal(List<Item> items) {
    double totalAmount = 0;
    for (Item item : items) {
        double price = item.getPrice();
        double quantity = item.getQuantity();
        double discount = item.getDiscount();
        totalAmount += price * quantity * (1 - discount);
    }
    return totalAmount;
}

public void createUser(String firstName, String lastName, String email, 
                      String phone, String address, int age) {
    // 建立使用者邏輯
}

public class UserInfo {
    private final String firstName;
    private final String lastName;
    private final String email;
    private final String phone;
    private final String address;
    private final int age;
    
    public UserInfo(String firstName, String lastName, String email, 
                   String phone, String address, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
        this.phone = phone;
        this.address = address;
        this.age = age;
    }
    
    // getters...
}

public void createUser(UserInfo userInfo) {
    // 建立使用者邏輯
}

public class OrderCalculator {
    public double calculateTotal(Order order) {
        double basePrice = order.getQuantity() * order.getItemPrice();
        double discountFactor = Math.max(0, order.getQuantity() - 500) * order.getItemPrice() * 0.05;
        double discountLevel2 = Math.min(discountFactor, order.getItemPrice() * 100);
        double shipping;
        
        if (basePrice > 1000) {
            shipping = 0;
        } else {
            shipping = basePrice * 0.1;
        }
        
        return basePrice - discountLevel2 + shipping;
    }
}

public class OrderCalculator {
    public double calculateTotal(Order order) {
        return new OrderTotalCalculation(order).calculate();
    }
}

class OrderTotalCalculation {
    private final Order order;
    private double basePrice;
    private double discountFactor;
    private double discountLevel2;
    private double shipping;
    
    public OrderTotalCalculation(Order order) {
        this.order = order;
    }
    
    public double calculate() {
        calculateBasePrice();
        calculateDiscount();
        calculateShipping();
        return basePrice - discountLevel2 + shipping;
    }
    
    private void calculateBasePrice() {
        basePrice = order.getQuantity() * order.getItemPrice();
    }
    
    private void calculateDiscount() {
        discountFactor = Math.max(0, order.getQuantity() - 500) * order.getItemPrice() * 0.05;
        discountLevel2 = Math.min(discountFactor, order.getItemPrice() * 100);
    }
    
    private void calculateShipping() {
        if (basePrice > 1000) {
            shipping = 0;
        } else {
            shipping = basePrice * 0.1;
        }
    }
}

public class Person {
    private String name;
    private String telephoneNumber;
    private String areaCode;
    
    public String getName() { return name; }
    public String getTelephoneNumber() { return telephoneNumber; }
    public String getAreaCode() { return areaCode; }
    
    public void setName(String name) { this.name = name; }
    public void setTelephoneNumber(String telephoneNumber) { 
        this.telephoneNumber = telephoneNumber; 
    }
    public void setAreaCode(String areaCode) { this.areaCode = areaCode; }
}

public class Person {
    private String name;
    private TelephoneNumber telephoneNumber;
    
    public String getName() { return name; }
    public TelephoneNumber getTelephoneNumber() { return telephoneNumber; }
    
    public void setName(String name) { this.name = name; }
    public void setTelephoneNumber(TelephoneNumber telephoneNumber) { 
        this.telephoneNumber = telephoneNumber; 
    }
}

public class TelephoneNumber {
    private String number;
    private String areaCode;
    
    public String getNumber() { return number; }
    public String getAreaCode() { return areaCode; }
    
    public void setNumber(String number) { this.number = number; }
    public void setAreaCode(String areaCode) { this.areaCode = areaCode; }
    
    public String getFullNumber() {
        return "(" + areaCode + ") " + number;
    }
}

public class Account {
    private AccountType type;
    private int daysOverdrawn;
    
    public double overdraftCharge() {
        if (type.isPremium()) {
            double result = 10;
            if (daysOverdrawn > 7) {
                result += (daysOverdrawn - 7) * 0.85;
            }
            return result;
        } else {
            return daysOverdrawn * 1.75;
        }
    }
}

public class Account {
    private AccountType type;
    private int daysOverdrawn;
    
    public double overdraftCharge() {
        return type.overdraftCharge(daysOverdrawn);
    }
}

public class AccountType {
    public double overdraftCharge(int daysOverdrawn) {
        if (isPremium()) {
            double result = 10;
            if (daysOverdrawn > 7) {
                result += (daysOverdrawn - 7) * 0.85;
            }
            return result;
        } else {
            return daysOverdrawn * 1.75;
        }
    }
    
    public boolean isPremium() {
        // 實作邏輯
    }
}

public class Bird {
    private BirdType type;
    
    public double getSpeed() {
        switch (type) {
            case EUROPEAN_SWALLOW:
                return getBaseSpeed();
            case AFRICAN_SWALLOW:
                return getBaseSpeed() - getLoadFactor() * numberOfCoconuts;
            case NORWEGIAN_BLUE_PARROT:
                return isNailed() ? 0 : getBaseSpeed(voltage);
        }
        throw new RuntimeException("未知的鳥類");
    }
}

public abstract class Bird {
    public abstract double getSpeed();
}

public class EuropeanSwallow extends Bird {
    @Override
    public double getSpeed() {
        return getBaseSpeed();
    }
}

public class AfricanSwallow extends Bird {
    private int numberOfCoconuts;
    
    @Override
    public double getSpeed() {
        return getBaseSpeed() - getLoadFactor() * numberOfCoconuts;
    }
}

public class NorwegianBlueParrot extends Bird {
    private boolean nailed;
    private double voltage;
    
    @Override
    public double getSpeed() {
        return nailed ? 0 : getBaseSpeed(voltage);
    }
}

public class OrderService {
    public String processOrder(String customerType, double orderAmount, 
                              int loyaltyPoints, boolean hasPromoCode) {
        double discount = 0;
        double finalAmount = orderAmount;
        
        // 計算折扣
        if (customerType.equals("VIP")) {
            discount = 0.2;
        } else if (customerType.equals("Premium")) {
            discount = 0.15;
        } else if (customerType.equals("Regular")) {
            discount = 0.1;
        }
        
        // 忠誠點數額外折扣
        if (loyaltyPoints > 1000) {
            discount += 0.05;
        }
        
        // 促銷代碼額外折扣
        if (hasPromoCode) {
            discount += 0.1;
        }
        
        finalAmount = orderAmount * (1 - discount);
        
        // 發送通知郵件
        String message = "您的訂單已處理完成";
        if (customerType.equals("VIP")) {
            message = "尊敬的 VIP 客戶，您的訂單已優先處理完成";
        }
        
        return "訂單處理成功，最終金額：" + finalAmount + "，通知訊息：" + message;
    }
}

// 原始程式碼（沒有測試）
public class LegacyOrderCalculator {
    public double calculateTotal(List<Item> items, String customerType) {
        double total = 0;
        for (Item item : items) {
            total += item.getPrice() * item.getQuantity();
        }
        
        // 複雜的折扣邏輯
        if (customerType.equals("VIP")) {
            total = total * 0.8;
        } else if (customerType.equals("Premium")) {
            total = total * 0.9;
        }
        
        return total;
    }
}

@Test
public class LegacyOrderCalculatorTest {
    private LegacyOrderCalculator calculator = new LegacyOrderCalculator();
    
    @Test
    public void testVipCustomerDiscount() {
        // 準備測試資料
        List<Item> items = Arrays.asList(
            new Item("產品A", 100.0, 2),
            new Item("產品B", 50.0, 1)
        );
        
        // 執行並驗證現有行為
        double result = calculator.calculateTotal(items, "VIP");
        assertEquals(200.0, result, 0.01); // (100*2 + 50*1) * 0.8 = 200
    }
    
    @Test
    public void testPremiumCustomerDiscount() {
        List<Item> items = Arrays.asList(
            new Item("產品A", 100.0, 1)
        );
        
        double result = calculator.calculateTotal(items, "Premium");
        assertEquals(90.0, result, 0.01); // 100 * 0.9 = 90
    }
    
    @Test
    public void testRegularCustomerNoDiscount() {
        List<Item> items = Arrays.asList(
            new Item("產品A", 100.0, 1)
        );
        
        double result = calculator.calculateTotal(items, "Regular");
        assertEquals(100.0, result, 0.01); // 100 * 1 = 100
    }
}

# Maven 專案
mvn test

# 確保所有測試通過
[INFO] Tests run: 15, Failures: 0, Errors: 0, Skipped: 0

// 重構步驟 1：提取方法
public double calculateTotal(List<Item> items, String customerType) {
    double subtotal = calculateSubtotal(items);
    double discount = calculateDiscount(customerType);
    return subtotal * (1 - discount);
}

private double calculateSubtotal(List<Item> items) {
    double total = 0;
    for (Item item : items) {
        total += item.getPrice() * item.getQuantity();
    }
    return total;
}

// 立即執行測試
// mvn test -Dtest=LegacyOrderCalculatorTest

// 1. 紅燈：寫失敗測試
@Test
public void testAddition() {
    Calculator calc = new Calculator();
    assertEquals(5, calc.add(2, 3));
}

// 2. 綠燈：最少程式碼
public class Calculator {
    public int add(int a, int b) {
        return 5; // 硬編碼讓測試通過
    }
}

// 3. 重構：改善實作
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

// 1. 紅燈：新測試
@Test
public void testSubtraction() {
    Calculator calc = new Calculator();
    assertEquals(1, calc.subtract(3, 2));
}

// 2. 綠燈：添加功能
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    
    public int subtract(int a, int b) {
        return a - b;
    }
}

// 3. 重構：沒有明顯的重構需求，繼續下個循環

// 使用 JaCoCo 檢查測試覆蓋率
// pom.xml 配置
<plugin>
    <groupId>org.jacoco</groupId>
    <artifactId>jacoco-maven-plugin</artifactId>
    <version>0.8.7</version>
    <executions>
        <execution>
            <goals>
                <goal>prepare-agent</goal>
            </goals>
        </execution>
        <execution>
            <id>report</id>
            <phase>test</phase>
            <goals>
                <goal>report</goal>
            </goals>
        </execution>
    </executions>
</plugin>

@Test
public void testOrderProcessingInternalDetails() {
    Order order = new Order();
    order.addItem(new Item("產品A", 100));
    
    // 測試內部實作細節
    assertEquals(1, order.getItems().size());
    assertEquals("產品A", order.getItems().get(0).getName());
    assertEquals(100.0, order.getItems().get(0).getPrice());
}

@Test
public void testOrderTotalCalculation() {
    Order order = new Order();
    order.addItem(new Item("產品A", 100));
    order.addItem(new Item("產品B", 50));
    
    // 測試外部行為
    assertEquals(150.0, order.getTotal());
}

public class OrderService {
    private PaymentGateway paymentGateway;
    private EmailService emailService;
    
    public OrderResult processOrder(Order order) {
        // 處理付款
        PaymentResult payment = paymentGateway.processPayment(order.getTotal());
        
        if (payment.isSuccessful()) {
            // 發送確認郵件
            emailService.sendConfirmation(order.getCustomerEmail());
            return OrderResult.success(order.getId());
        } else {
            return OrderResult.failure("付款失敗");
        }
    }
}

@Test
public void testSuccessfulOrderProcessing() {
    // 使用 Mock 物件
    PaymentGateway mockPayment = mock(PaymentGateway.class);
    EmailService mockEmail = mock(EmailService.class);
    
    when(mockPayment.processPayment(100.0))
        .thenReturn(PaymentResult.successful());
    
    OrderService service = new OrderService(mockPayment, mockEmail);
    Order order = new Order("customer@example.com", 100.0);
    
    OrderResult result = service.processOrder(order);
    
    assertTrue(result.isSuccessful());
    verify(mockEmail).sendConfirmation("customer@example.com");
}

// 範例：重構效益計算
public class RefactoringBenefitCalculator {
    
    public RefactoringDecision evaluateRefactoring(CodeMetrics metrics) {
        double complexityScore = calculateComplexityScore(metrics);
        double maintainabilityScore = calculateMaintainabilityScore(metrics);
        double riskScore = calculateRiskScore(metrics);
        
        double benefitScore = (complexityScore + maintainabilityScore) / 2;
        double costScore = riskScore;
        
        if (benefitScore > costScore * 1.5) {
            return RefactoringDecision.PROCEED;
        } else if (benefitScore > costScore) {
            return RefactoringDecision.CONSIDER;
        } else {
            return RefactoringDecision.POSTPONE;
        }
    }
}

// 步驟 1：建立介面包裝舊系統
public interface OrderService {
    OrderResult processOrder(OrderRequest request);
}

public class LegacyOrderServiceWrapper implements OrderService {
    private LegacyOrderSystem legacySystem;
    
    @Override
    public OrderResult processOrder(OrderRequest request) {
        // 轉換請求格式
        LegacyOrderRequest legacyRequest = convertToLegacyFormat(request);
        
        // 呼叫舊系統
        LegacyOrderResponse legacyResponse = legacySystem.process(legacyRequest);
        
        // 轉換回應格式
        return convertToNewFormat(legacyResponse);
    }
}

// 步驟 2：逐步替換為新實作
public class NewOrderService implements OrderService {
    @Override
    public OrderResult processOrder(OrderRequest request) {
        // 新的實作邏輯
        return processWithNewLogic(request);
    }
}

// 步驟 3：使用 Feature Toggle 控制切換
public class OrderServiceFactory {
    @Value("${feature.new-order-service.enabled:false}")
    private boolean useNewService;
    
    public OrderService createOrderService() {
        if (useNewService) {
            return new NewOrderService();
        } else {
            return new LegacyOrderServiceWrapper();
        }
    }
}

// 步驟 1：建立抽象層
public abstract class PaymentProcessor {
    public abstract PaymentResult process(PaymentRequest request);
}

// 步驟 2：包裝現有實作
public class OldPaymentProcessor extends PaymentProcessor {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // 現有的付款處理邏輯
        return legacyPaymentSystem.processPayment(request);
    }
}

// 步驟 3：建立新實作
public class NewPaymentProcessor extends PaymentProcessor {
    @Override
    public PaymentResult process(PaymentRequest request) {
        // 新的付款處理邏輯
        return newPaymentGateway.processPayment(request);
    }
}

// 步驟 4：逐步切換
public class PaymentService {
    private PaymentProcessor processor;
    
    public PaymentService(@Qualifier("paymentProcessor") PaymentProcessor processor) {
        this.processor = processor;
    }
    
    public PaymentResult processPayment(PaymentRequest request) {
        return processor.process(request);
    }
}

@Component
public class PerformanceMonitor {
    
    @Around("@annotation(Monitored)")
    public Object monitorPerformance(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime = System.nanoTime();
        
        try {
            Object result = joinPoint.proceed();
            long endTime = System.nanoTime();
            
            logPerformance(joinPoint.getSignature().getName(), 
                          endTime - startTime, "SUCCESS");
            
            return result;
        } catch (Exception e) {
            long endTime = System.nanoTime();
            logPerformance(joinPoint.getSignature().getName(), 
                          endTime - startTime, "ERROR");
            throw e;
        }
    }
    
    private void logPerformance(String methodName, long duration, String status) {
        logger.info("Method: {}, Duration: {}ns, Status: {}", 
                   methodName, duration, status);
        
        // 發送監控指標到監控系統
        metricsCollector.recordMethodDuration(methodName, duration);
    }
}

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
public class OrderProcessingBenchmark {
    
    private OrderService oldOrderService;
    private OrderService newOrderService;
    private OrderRequest testRequest;
    
    @Setup
    public void setup() {
        oldOrderService = new OldOrderService();
        newOrderService = new NewOrderService();
        testRequest = createTestOrderRequest();
    }
    
    @Benchmark
    public OrderResult benchmarkOldService() {
        return oldOrderService.processOrder(testRequest);
    }
    
    @Benchmark
    public OrderResult benchmarkNewService() {
        return newOrderService.processOrder(testRequest);
    }
}

<!-- Maven 配置：SonarQube + Checkstyle + PMD -->
<plugin>
    <groupId>org.sonarsource.scanner.maven</groupId>
    <artifactId>sonar-maven-plugin</artifactId>
    <version>3.9.1.2184</version>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-checkstyle-plugin</artifactId>
    <version>3.1.2</version>
    <configuration>
        <configLocation>checkstyle.xml</configLocation>
        <failOnViolation>true</failOnViolation>
        <violationSeverity>warning</violationSeverity>
    </configuration>
</plugin>

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-pmd-plugin</artifactId>
    <version>3.15.0</version>
    <configuration>
        <targetJdk>11</targetJdk>
        <rulesets>
            <ruleset>/rulesets/java/quickstart.xml</ruleset>
        </rulesets>
    </configuration>
</plugin>

// 建議重構建議
這個方法有點長（45行），建議考慮提取以下邏輯：
1. 資料驗證邏輯 (line 10-20)
2. 業務計算邏輯 (line 25-35)
3. 結果封裝邏輯 (line 40-45)

這樣可以提高可讀性和可測試性。

// 不好的審查意見
這個程式碼很亂，需要重寫。

// ✅ 良好的類別命名
public class OrderCalculator { }
public class UserValidator { }
public class PaymentGateway { }

// ❌ 不佳的類別命名
public class OrderUtils { }        // 太籠統
public class DataProcessor { }     // 職責不明確
public class Manager { }           // 沒有意義

// ✅ 良好的方法命名
public void calculateTotalAmount() { }
public boolean isValidEmail(String email) { }
public List<Order> findOrdersByCustomerId(Long customerId) { }

// ❌ 不佳的方法命名
public void calc() { }             // 太簡短
public boolean check(String s) { } // 不明確
public void doStuff() { }          // 無意義

com.company.project
├── config/          # 配置相關
├── controller/      # 控制器層
├── service/         # 業務服務層
│   ├── impl/       # 服務實作
│   └── dto/        # 資料傳輸物件
├── repository/      # 資料存取層
├── domain/          # 領域模型
│   ├── entity/     # 實體類別
│   ├── valueobject/ # 值物件
│   └── aggregate/   # 聚合根
└── util/           # 工具類別

// ✅ 單一職責的服務類別
@Service
public class OrderService {
    // 只負責訂單相關的業務邏輯
    public OrderResult processOrder(OrderRequest request) { }
    public void cancelOrder(Long orderId) { }
    public OrderStatus getOrderStatus(Long orderId) { }
}

@Service
public class PaymentService {
    // 只負責付款相關的業務邏輯
    public PaymentResult processPayment(PaymentRequest request) { }
    public void refundPayment(Long paymentId) { }
}

// ❌ 違反單一職責的類別
@Service
public class OrderManagerService {
    // 混合了多種職責
    public OrderResult processOrder(OrderRequest request) { }
    public PaymentResult processPayment(PaymentRequest request) { }
    public void sendEmail(String to, String content) { }
    public void generateReport() { }
}

# .github/workflows/code-quality.yml
name: Code Quality Check

on:
  pull_request:
    branches: [ main, develop ]

jobs:
  code-quality:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up JDK 11
      uses: actions/setup-java@v3
      with:
        java-version: '11'
        distribution: 'temurin'
        
    - name: Cache Maven packages
      uses: actions/cache@v3
      with:
        path: ~/.m2
        key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
        
    - name: Run tests
      run: mvn test
      
    - name: Run SonarQube analysis
      run: mvn sonar:sonar -Dsonar.projectKey=my-project
      
    - name: Check test coverage
      run: mvn jacoco:check
      
    - name: Checkstyle check
      run: mvn checkstyle:check

// .vscode/settings.json
{
    "java.format.settings.url": "./eclipse-formatter.xml",
    "java.checkstyle.configuration": "./checkstyle.xml",
    "java.test.defaultConfig": "default",
    "sonarlint.connectedMode.project": {
        "connectionId": "my-sonarqube",
        "projectKey": "my-project"
    }
}

// 考試題型：識別以下程式碼的壞味道並提出重構建議
public class CustomerManager {
    public String processCustomer(String name, String email, String phone, 
                                 String address, String type, boolean active) {
        
        // 驗證邏輯
        if (name == null || name.trim().isEmpty()) return "姓名不能為空";
        if (email == null || !email.contains("@")) return "電子郵件格式錯誤";
        if (phone == null || phone.length() < 10) return "電話號碼格式錯誤";
        
        // 處理邏輯
        if (type.equals("VIP")) {
            // VIP 客戶處理
            saveToDatabase(name, email, phone, address, type, active);
            sendWelcomeEmail(email, "VIP");
            createLoyaltyAccount(email);
            return "VIP 客戶建立成功";
        } else if (type.equals("Premium")) {
            // Premium 客戶處理
            saveToDatabase(name, email, phone, address, type, active);
            sendWelcomeEmail(email, "Premium");
            return "Premium 客戶建立成功";
        } else {
            // 一般客戶處理
            saveToDatabase(name, email, phone, address, type, active);
            sendWelcomeEmail(email, "Regular");
            return "一般客戶建立成功";
        }
    }
}

// 現有程式碼
public class OrderProcessor {
    public void processOrder(Order order) {
        // 150 行程式碼包含：
        // - 訂單驗證
        // - 庫存檢查
        // - 價格計算
        // - 付款處理
        // - 發送通知
        // - 記錄日誌
    }
}

public class Calculator {
    public double calculate(double a, double b, String operation) {
        if (operation.equals("add")) {
            return a + b;
        } else if (operation.equals("subtract")) {
            return a - b;
        } else if (operation.equals("multiply")) {
            return a * b;
        } else if (operation.equals("divide")) {
            if (b == 0) {
                throw new IllegalArgumentException("不能除以零");
            }
            return a / b;
        } else {
            throw new IllegalArgumentException("不支援的運算：" + operation);
        }
    }
}

// 步驟 1：引入列舉
public enum Operation {
    ADD, SUBTRACT, MULTIPLY, DIVIDE
}

// 步驟 2：重構主要方法
public class Calculator {
    public double calculate(double a, double b, Operation operation) {
        switch (operation) {
            case ADD:
                return add(a, b);
            case SUBTRACT:
                return subtract(a, b);
            case MULTIPLY:
                return multiply(a, b);
            case DIVIDE:
                return divide(a, b);
            default:
                throw new IllegalArgumentException("不支援的運算：" + operation);
        }
    }
    
    private double add(double a, double b) {
        return a + b;
    }
    
    private double subtract(double a, double b) {
        return a - b;
    }
    
    private double multiply(double a, double b) {
        return a * b;
    }
    
    private double divide(double a, double b) {
        if (b == 0) {
            throw new IllegalArgumentException("不能除以零");
        }
        return a / b;
    }
}

// 步驟 3：更進一步使用策略模式
public interface CalculationStrategy {
    double calculate(double a, double b);
}

public class AdditionStrategy implements CalculationStrategy {
    @Override
    public double calculate(double a, double b) {
        return a + b;
    }
}

public class Calculator {
    private Map<Operation, CalculationStrategy> strategies = Map.of(
        Operation.ADD, new AdditionStrategy(),
        Operation.SUBTRACT, (a, b) -> a - b,
        Operation.MULTIPLY, (a, b) -> a * b,
        Operation.DIVIDE, (a, b) -> {
            if (b == 0) throw new IllegalArgumentException("不能除以零");
            return a / b;
        }
    );
    
    public double calculate(double a, double b, Operation operation) {
        CalculationStrategy strategy = strategies.get(operation);
        if (strategy == null) {
            throw new IllegalArgumentException("不支援的運算：" + operation);
        }
        return strategy.calculate(a, b);
    }
}

public class ReportGenerator {
    public String generateReport(String customerType, List<Order> orders, 
                               String format, boolean includeDetails, 
                               Date startDate, Date endDate, 
                               String sortBy, boolean ascending) {
        
        StringBuilder report = new StringBuilder();
        
        // 過濾訂單
        List<Order> filteredOrders = new ArrayList<>();
        for (Order order : orders) {
            if (order.getDate().after(startDate) && order.getDate().before(endDate)) {
                if (customerType.equals("VIP") && order.getCustomer().getType().equals("VIP")) {
                    filteredOrders.add(order);
                } else if (customerType.equals("Regular") && !order.getCustomer().getType().equals("VIP")) {
                    filteredOrders.add(order);
                } else if (customerType.equals("All")) {
                    filteredOrders.add(order);
                }
            }
        }
        
        // 排序
        if (sortBy.equals("date")) {
            filteredOrders.sort((o1, o2) -> ascending ? 
                o1.getDate().compareTo(o2.getDate()) : 
                o2.getDate().compareTo(o1.getDate()));
        } else if (sortBy.equals("amount")) {
            filteredOrders.sort((o1, o2) -> ascending ? 
                Double.compare(o1.getAmount(), o2.getAmount()) : 
                Double.compare(o2.getAmount(), o1.getAmount()));
        }
        
        // 生成報表
        if (format.equals("CSV")) {
            report.append("Order ID,Customer,Amount,Date\n");
            for (Order order : filteredOrders) {
                report.append(order.getId()).append(",")
                      .append(order.getCustomer().getName()).append(",")
                      .append(order.getAmount()).append(",")
                      .append(order.getDate()).append("\n");
                
                if (includeDetails) {
                    for (OrderItem item : order.getItems()) {
                        report.append("  ").append(item.getName()).append(",")
                              .append(item.getQuantity()).append(",")
                              .append(item.getPrice()).append("\n");
                    }
                }
            }
        } else if (format.equals("JSON")) {
            // JSON 格式生成邏輯（50行）
            // ...
        } else if (format.equals("XML")) {
            // XML 格式生成邏輯（60行）
            // ...
        }
        
        return report.toString();
    }
}

public class AdvancedCalculator {
    public double compute(String expression) {
        String[] parts = expression.split(" ");
        
        if (parts.length != 3) {
            throw new IllegalArgumentException("Invalid expression");
        }
        
        double num1 = Double.parseDouble(parts[0]);
        String operator = parts[1];
        double num2 = Double.parseDouble(parts[2]);
        
        if (operator.equals("+")) {
            return num1 + num2;
        } else if (operator.equals("-")) {
            return num1 - num2;
        } else if (operator.equals("*")) {
            return num1 * num2;
        } else if (operator.equals("/")) {
            if (num2 == 0) {
                throw new IllegalArgumentException("Division by zero");
            }
            return num1 / num2;
        } else if (operator.equals("^")) {
            return Math.pow(num1, num2);
        } else if (operator.equals("%")) {
            return num1 % num2;
        } else {
            throw new IllegalArgumentException("Unsupported operator: " + operator);
        }
    }
}

// 1. 引入策略模式
public enum Operator {
    ADD("+", (a, b) -> a + b),
    SUBTRACT("-", (a, b) -> a - b),
    MULTIPLY("*", (a, b) -> a * b),
    DIVIDE("/", (a, b) -> {
        if (b == 0) throw new IllegalArgumentException("Division by zero");
        return a / b;
    }),
    POWER("^", Math::pow),
    MODULO("%", (a, b) -> a % b);
    
    private final String symbol;
    private final BinaryOperator<Double> operation;
    
    Operator(String symbol, BinaryOperator<Double> operation) {
        this.symbol = symbol;
        this.operation = operation;
    }
    
    public static Operator fromSymbol(String symbol) {
        return Arrays.stream(values())
                .filter(op -> op.symbol.equals(symbol))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("Unsupported operator: " + symbol));
    }
    
    public double apply(double a, double b) {
        return operation.apply(a, b);
    }
}

// 2. 重構後的計算機
public class AdvancedCalculator {
    public double compute(String expression) {
        Expression expr = parseExpression(expression);
        return expr.evaluate();
    }
    
    private Expression parseExpression(String expression) {
        String[] parts = expression.trim().split("\\s+");
        
        if (parts.length != 3) {
            throw new IllegalArgumentException("Invalid expression format. Expected: 'number operator number'");
        }
        
        try {
            double operand1 = Double.parseDouble(parts[0]);
            Operator operator = Operator.fromSymbol(parts[1]);
            double operand2 = Double.parseDouble(parts[2]);
            
            return new Expression(operand1, operator, operand2);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Invalid number format in expression", e);
        }
    }
}

// 3. 表達式值物件
public class Expression {
    private final double operand1;
    private final Operator operator;
    private final double operand2;
    
    public Expression(double operand1, Operator operator, double operand2) {
        this.operand1 = operand1;
        this.operator = operator;
        this.operand2 = operand2;
    }
    
    public double evaluate() {
        return operator.apply(operand1, operand2);
    }
}

// 4. 測試類別
@Test
public class AdvancedCalculatorTest {
    private AdvancedCalculator calculator = new AdvancedCalculator();
    
    @Test
    public void testBasicOperations() {
        assertEquals(5.0, calculator.compute("2 + 3"), 0.001);
        assertEquals(1.0, calculator.compute("3 - 2"), 0.001);
        assertEquals(6.0, calculator.compute("2 * 3"), 0.001);
        assertEquals(2.0, calculator.compute("6 / 3"), 0.001);
    }
    
    @Test
    public void testAdvancedOperations() {
        assertEquals(8.0, calculator.compute("2 ^ 3"), 0.001);
        assertEquals(1.0, calculator.compute("5 % 2"), 0.001);
    }
    
    @Test
    public void testDivisionByZero() {
        assertThrows(IllegalArgumentException.class, 
                    () -> calculator.compute("5 / 0"));
    }
    
    @Test
    public void testInvalidExpression() {
        assertThrows(IllegalArgumentException.class, 
                    () -> calculator.compute("2 +"));
        assertThrows(IllegalArgumentException.class, 
                    () -> calculator.compute("abc + 3"));
    }
}