Java面试官眼中的优秀代码：代码规范与可维护性的展示

在Java开发领域，写出能运行的代码只是基本要求，而写出优秀代码才是区分普通开发者和高级开发者的关键。作为面试官，我经常通过候选人的代码来评估其专业素养和工程能力。本文将深入探讨优秀Java代码的核心特征，并通过具体示例展示如何编写符合面试官期待的代码。

一、代码规范：优秀代码的基石

1.1 命名规范的实践

优秀的命名应该做到"见名知意"，避免使用缩写和魔法数字。对比以下两段代码：

// 不良实践
public List<String> getUsrLst(int t) {
    List<String> l = new ArrayList<>();
    if (t > 7) {
        l.add("vip");
    }
    return l;
}

// 良好实践
public List<String> getUserListByType(int userType) {
    List<String> userCategories = new ArrayList<>();
    final int VIP_USER_THRESHOLD = 7;
    
    if (userType > VIP_USER_THRESHOLD) {
        userCategories.add("VIP");
    }
    return userCategories;
}

1.2 代码格式的一致性

一致的代码格式显著提升可读性。建议遵循Google Java Style Guide：

// 类定义
public class OrderProcessor {
    // 常量
    private static final int MAX_RETRY_COUNT = 3;
    
    // 成员变量
    private final PaymentGateway paymentGateway;
    
    // 构造方法
    public OrderProcessor(PaymentGateway paymentGateway) {
        this.paymentGateway = paymentGateway;
    }
    
    // 方法
    public void processOrder(Order order) throws PaymentException {
        validateOrder(order);
        
        int retryCount = 0;
        while (retryCount < MAX_RETRY_COUNT) {
            try {
                paymentGateway.charge(order);
                return;
            } catch (PaymentException e) {
                retryCount++;
                if (retryCount == MAX_RETRY_COUNT) {
                    throw e;
                }
            }
        }
    }
    
    // 私有方法
    private void validateOrder(Order order) {
        // 验证逻辑
    }
}

二、可维护性设计原则

2.1 SOLID原则的应用

单一职责原则示例：

// 不良实践：一个类承担多重责任
public class ReportGenerator {
    public void generateReport(Data data) {
        // 生成报告
    }
    
    public void saveToFile(Report report, String filePath) {
        // 保存到文件
    }
    
    public void printReport(Report report) {
        // 打印报告
    }
}

// 良好实践：职责分离
public class ReportGenerator {
    public Report generateReport(Data data) {
        // 生成报告
    }
}

public class ReportSaver {
    public void saveToFile(Report report, String filePath) {
        // 保存到文件
    }
}

public class ReportPrinter {
    public void printReport(Report report) {
        // 打印报告
    }
}

开闭原则示例：

// 良好实践：通过接口扩展
public interface DiscountStrategy {
    BigDecimal applyDiscount(BigDecimal amount);
}

public class NoDiscount implements DiscountStrategy {
    @Override
    public BigDecimal applyDiscount(BigDecimal amount) {
        return amount;
    }
}

public class PercentageDiscount implements DiscountStrategy {
    private final BigDecimal percentage;
    
    public PercentageDiscount(BigDecimal percentage) {
        this.percentage = percentage;
    }
    
    @Override
    public BigDecimal applyDiscount(BigDecimal amount) {
        return amount.multiply(BigDecimal.ONE.subtract(percentage));
    }
}

public class Order {
    private final DiscountStrategy discountStrategy;
    
    public Order(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }
    
    public BigDecimal calculateFinalPrice(BigDecimal originalPrice) {
        return discountStrategy.applyDiscount(originalPrice);
    }
}

2.2 防御性编程

public class UserService {
    private final UserRepository userRepository;
    
    public UserService(UserRepository userRepository) {
        this.userRepository = Objects.requireNonNull(userRepository, 
            "UserRepository must not be null");
    }
    
    public User getUserById(String userId) {
        if (userId == null || userId.trim().isEmpty()) {
            throw new IllegalArgumentException("User ID must not be null or empty");
        }
        
        return userRepository.findById(userId)
                .orElseThrow(() -> new UserNotFoundException(
                    "User not found with ID: " + userId));
    }
    
    public void updateUserEmail(String userId, String newEmail) {
        validateEmail(newEmail);
        User user = getUserById(userId);
        user.setEmail(newEmail);
        userRepository.save(user);
    }
    
    private void validateEmail(String email) {
        // 实现邮箱验证逻辑
    }
}

三、测试友好的代码设计

3.1 依赖注入与模拟

public class OrderService {
    private final PaymentGateway paymentGateway;
    private final InventoryService inventoryService;
    private final NotificationService notificationService;
    
    // 构造器注入
    public OrderService(PaymentGateway paymentGateway,
                       InventoryService inventoryService,
                       NotificationService notificationService) {
        this.paymentGateway = paymentGateway;
        this.inventoryService = inventoryService;
        this.notificationService = notificationService;
    }
    
    public OrderResult processOrder(Order order) {
        // 处理订单逻辑
        boolean paymentSuccess = paymentGateway.processPayment(order);
        if (paymentSuccess) {
            inventoryService.updateInventory(order);
            notificationService.sendOrderConfirmation(order);
            return OrderResult.success();
        }
        return OrderResult.failed("Payment failed");
    }
}

// 测试类
class OrderServiceTest {
    @Test
    void processOrder_Success() {
        // 准备mock对象
        PaymentGateway mockPaymentGateway = mock(PaymentGateway.class);
        when(mockPaymentGateway.processPayment(any())).thenReturn(true);
        
        InventoryService mockInventory = mock(InventoryService.class);
        NotificationService mockNotification = mock(NotificationService.class);
        
        // 创建测试对象
        OrderService orderService = new OrderService(
            mockPaymentGateway, mockInventory, mockNotification);
        
        // 执行测试
        OrderResult result = orderService.processOrder(new Order());
        
        // 验证结果
        assertTrue(result.isSuccess());
        verify(mockInventory).updateInventory(any());
        verify(mockNotification).sendOrderConfirmation(any());
    }
}

3.2 可测试的方法设计

public class PriceCalculator {
    // 可测试的纯函数
    public static BigDecimal calculateDiscountedPrice(
        BigDecimal originalPrice, 
        BigDecimal discount, 
        boolean isPercentage) {
        
        Objects.requireNonNull(originalPrice, "Original price must not be null");
        Objects.requireNonNull(discount, "Discount must not be null");
        
        if (originalPrice.compareTo(BigDecimal.ZERO) < 0) {
            throw new IllegalArgumentException("Price must be positive");
        }
        
        if (isPercentage) {
            if (discount.compareTo(BigDecimal.ZERO) < 0 || 
                discount.compareTo(BigDecimal.ONE) > 0) {
                throw new IllegalArgumentException(
                    "Percentage discount must be between 0 and 1");
            }
            return originalPrice.multiply(BigDecimal.ONE.subtract(discount));
        } else {
            if (discount.compareTo(BigDecimal.ZERO) < 0 || 
                discount.compareTo(originalPrice) > 0) {
                throw new IllegalArgumentException(
                    "Fixed discount must be positive and less than price");
            }
            return originalPrice.subtract(discount);
        }
    }
}

// 测试类
class PriceCalculatorTest {
    @Test
    void calculateDiscountedPrice_PercentageDiscount() {
        BigDecimal result = PriceCalculator.calculateDiscountedPrice(
            new BigDecimal("100.00"), 
            new BigDecimal("0.20"), 
            true);
        
        assertEquals(new BigDecimal("80.00"), result);
    }
    
    @Test
    void calculateDiscountedPrice_InvalidPercentage() {
        assertThrows(IllegalArgumentException.class, () -> {
            PriceCalculator.calculateDiscountedPrice(
                new BigDecimal("100.00"), 
                new BigDecimal("1.20"), 
                true);
        });
    }
}

四、性能与可读性的平衡

4.1 高效集合使用

public class UserStatistics {
    // 不良实践：低效的集合操作
    public List<String> findCommonUsers(List<String> list1, List<String> list2) {
        List<String> result = new ArrayList<>();
        for (String user1 : list1) {
            for (String user2 : list2) {
                if (user1.equals(user2)) {
                    result.add(user1);
                }
            }
        }
        return result;
    }
    
    // 良好实践：使用Set提高效率
    public List<String> findCommonUsersOptimized(List<String> list1, List<String> list2) {
        Set<String> set2 = new HashSet<>(list2);
        return list1.stream()
                .filter(set2::contains)
                .collect(Collectors.toList());
    }
}

4.2 字符串处理优化

public class StringProcessor {
    // 不良实践：字符串拼接性能差
    public String buildMessage(List<String> parts) {
        String result = "";
        for (String part : parts) {
            result += part;
        }
        return result;
    }
    
    // 良好实践：使用StringBuilder
    public String buildMessageOptimized(List<String> parts) {
        StringBuilder builder = new StringBuilder();
        for (String part : parts) {
            builder.append(part);
        }
        return builder.toString();
    }
    
    // Java 8+ 更简洁的实现
    public String buildMessageWithStream(List<String> parts) {
        return parts.stream().collect(Collectors.joining());
    }
}

五、现代Java特性的合理使用

5.1 Optional的正确用法

public class UserService {
    private final UserRepository userRepository;
    
    // 不良实践：可能返回null
    public String getUserEmail(Long userId) {
        User user = userRepository.findById(userId);
        return user != null ? user.getEmail() : null;
    }
    
    // 良好实践：使用Optional明确表示可能无值
    public Optional<String> getUserEmailSafe(Long userId) {
        return Optional.ofNullable(userRepository.findById(userId))
                .map(User::getEmail);
    }
    
    // 使用示例
    public void sendEmailIfPresent(Long userId) {
        getUserEmailSafe(userId).ifPresent(email -> {
            // 发送邮件逻辑
            System.out.println("Sending email to: " + email);
        });
    }
}

5.2 记录类(Record)的使用

// 传统Java类
public final class Point {
    private final double x;
    private final double y;
    
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
    
    public double x() { return x; }
    public double y() { return y; }
    
    @Override
    public boolean equals(Object o) {
        // 冗长的equals实现
    }
    
    @Override
    public int hashCode() {
        // hashCode实现
    }
    
    @Override
    public String toString() {
        // toString实现
    }
}

// Java 14+ 记录类
public record Point(double x, double y) {
    // 编译器自动生成:
    // 1. 规范构造函数
    // 2. 访问器方法x()和y()
    // 3. equals(), hashCode(), toString()
    
    // 可以添加自定义方法
    public double distanceFromOrigin() {
        return Math.sqrt(x * x + y * y);
    }
}

结语

优秀的Java代码不仅仅是功能实现，更是艺术与工程的结合。作为面试官，我们期待看到候选人能够：

1. 严格遵守代码规范，写出整洁易读的代码
2. 遵循SOLID等设计原则，创建可维护的架构
3. 编写测试友好的代码，体现工程化思维
4. 在性能和可读性之间取得良好平衡
5. 合理使用现代Java特性提升代码质量

记住，优秀的代码是团队协作的基础，也是个人专业能力的体现。在日常开发中培养这些好习惯，你将在面试和实际工作中脱颖而出。