// 差：返回错误码
public class DeviceController {
  public int sendShutdown(int deviceId) {
    if (deviceId < 0) {
      return -1; // 错误码：无效设备
    }
    if (!deviceExists(deviceId)) {
      return -2; // 错误码：设备不存在
    }
    // 发送关闭命令
    return 0; // 成功
  }
}

// 调用者必须检查返回值
int result = controller.sendShutdown(1);
if (result == -1) {
  // 处理无效设备
} else if (result == -2) {
  // 处理设备不存在
}
// 容易忘记检查！

// 好：使用异常
public class DeviceController {
  public void sendShutdown(int deviceId) {
    if (deviceId < 0) {
      throw new IllegalArgumentException("Device ID must be positive");
    }
    if (!deviceExists(deviceId)) {
      throw new DeviceNotFoundException("Device not found: " + deviceId);
    }
    // 发送关闭命令
  }
}

// 调用者无法忽略异常
try {
  controller.sendShutdown(1);
} catch (DeviceNotFoundException e) {
  // 处理设备不存在
}

// 从异常开始设计
public class StorageService {
  
  public void saveFile(String content, String fileName) {
    try {
      // 先写 try 块
      FileOutputStream fos = new FileOutputStream(fileName);
      fos.write(content.getBytes());
      fos.close();
    } catch (FileNotFoundException e) {
      // 再写 catch 块
      logger.error("File not found: {}", fileName, e);
      throw new StorageException("Cannot save file: " + fileName, e);
    } catch (IOException e) {
      logger.error("IO error saving file: {}", fileName, e);
      throw new StorageException("IO error: " + fileName, e);
    } finally {
      // 最后写 finally 块
      // 确保资源释放
    }
  }
}

// 差：异常信息不足
try {
  // ...
} catch (Exception e) {
  throw new RuntimeException("Error"); // 什么错误？在哪里？
}

// 好：包含上下文
try {
  processOrder(order);
} catch (PaymentException e) {
  throw new OrderProcessingException(
      "Failed to process order " + order.getId() + 
      " for customer " + order.getCustomerId() + 
      ": " + e.getMessage(), e);
}

// checked 异常：强制处理，但增加代码噪音
public void readFile(String path) throws IOException {
  // 每个调用者都必须处理 IOException
}

// unchecked 异常：不强制处理，减少噪音
public void readFile(String path) {
  try {
    // 读取文件
  } catch (IOException e) {
    throw new UncheckedIOException("Cannot read file: " + path, e);
  }
}

// 差：返回 null
public List<Order> getOrders(CustomerId customerId) {
  List<Order> orders = orderRepository.findByCustomerId(customerId);
  if (orders == null) {
    return null; // 调用者必须检查 null
  }
  return orders;
}

// 调用者
List<Order> orders = service.getOrders(customerId);
if (orders != null) { // 容易忘记检查！
  for (Order order : orders) {
    // ...
  }
}

// 好：不返回 null
public List<Order> getOrders(CustomerId customerId) {
  List<Order> orders = orderRepository.findByCustomerId(customerId);
  return orders != null ? orders : Collections.emptyList();
}

// 调用者不需要检查 null
List<Order> orders = service.getOrders(customerId);
for (Order order : orders) { // 安全，空列表不会进入循环
  // ...
}

// 使用 Optional 替代 null
public Optional<User> findUser(UserId userId) {
  User user = userRepository.findById(userId);
  return Optional.ofNullable(user);
}

// 调用者
Optional<User> user = service.findUser(userId);
user.ifPresent(u -> {
  // 处理用户
});

// 或者
User user = service.findUser(userId)
    .orElseThrow(() -> new UserNotFoundException(userId));

// 改善前：混乱的错误处理
public String processOrder(Order order) {
  if (order == null) return "error: null order";
  if (order.getItems().isEmpty()) return "error: no items";
  
  try {
    double total = 0;
    for (Item item : order.getItems()) {
      total += item.getPrice() * item.getQuantity();
    }
    // 保存
    database.save(order);
    return "success";
  } catch (Exception e) {
    return "error: " + e.getMessage();
  }
}

// 改善后：清晰的错误处理
public class OrderService {
  
  public OrderResult processOrder(Order order) {
    validateOrder(order);
    
    try {
      Money total = calculateTotal(order);
      order.setTotal(total);
      orderRepository.save(order);
      return OrderResult.success(order.getId());
    } catch (DatabaseException e) {
      logger.error("Failed to save order {}: {}", 
                   order.getId(), e.getMessage(), e);
      return OrderResult.systemError("Failed to save order");
    }
  }
  
  private void validateOrder(Order order) {
    if (order == null) {
      throw new IllegalArgumentException("Order must not be null");
    }
    if (order.getItems().isEmpty()) {
      throw new IllegalArgumentException("Order must have items");
    }
  }
}

// 结果对象
public class OrderResult {
  private final boolean success;
  private final OrderId orderId;
  private final String errorMessage;
  
  public static OrderResult success(OrderId orderId) {
    return new OrderResult(true, orderId, null);
  }
  
  public static OrderResult systemError(String message) {
    return new OrderResult(false, null, message);
  }
}