一、方法设计的核心原则：参数与返回值的优化

1.1 参数校验的防御性编程

在《Effective Java 中文第三版》中，防御性编程被反复强调。方法入口处的参数校验是防止非法输入破坏内部状态的关键。例如，在实现一个计算平方根的方法时，若未校验负数输入，将导致ArithmeticException或返回无效结果：

// 非防御性实现（存在风险）
public double sqrt(double x) {
    return Math.sqrt(x); // 若x为负数，返回NaN
}
// 防御性实现（推荐）
public double sqrt(double x) {
    if (x < 0) {
        throw new IllegalArgumentException("输入不能为负数: " + x);
    }
    return Math.sqrt(x);
}

防御性编程的核心是尽早失败（Fail Fast），将错误暴露在方法边界而非内部逻辑中。这不仅提升代码健壮性，还能简化调试过程。

1.2 返回值的不可变性设计

方法返回的对象应尽可能不可变，以避免外部修改破坏内部状态。例如，Collections.unmodifiableList通过包装原始列表生成不可变视图：

public List<String> getImmutableList() {
    List<String> mutableList = new ArrayList<>();
    mutableList.add("A");
    mutableList.add("B");
    return Collections.unmodifiableList(mutableList);
}

调用者若尝试修改返回的列表（如add或remove），将直接抛出UnsupportedOperationException。这种设计在并发场景中尤为重要，可避免因共享可变对象导致的数据竞争。

二、类设计的进阶实践：继承与组合的权衡

2.1 继承的局限性分析

《Effective Java 中文第三版》明确指出：继承会破坏封装性。子类可能依赖父类的实现细节，导致父类修改时子类行为异常。例如，HashSet的add方法依赖内部哈希表结构，若子类重写该方法并修改逻辑，可能破坏集合的唯一性约束：

// 危险示例：子类破坏父类契约
class UnsafeSet<E> extends HashSet<E> {
    @Override
    public boolean add(E e) {
        return false; // 强制所有添加操作失败
    }
}

此类设计会导致调用者对add方法的预期（添加元素并返回是否成功）被违背，引发难以排查的错误。

2.2 组合优于继承的实践

组合通过持有其他类的实例并委托调用其方法，实现更灵活的复用。例如，实现一个支持大小写不敏感的字符串集合：

class CaseInsensitiveSet<E> {
    private final Set<String> delegate;
    public CaseInsensitiveSet(Set<String> delegate) {
        this.delegate = Objects.requireNonNull(delegate);
    }
    public boolean add(String s) {
        return delegate.add(s.toLowerCase());
    }
    // 委托其他Set方法...
}

组合的优势在于：

隔离变化：父类内部修改不影响子类。
功能扩展：可自由组合多个类的能力（如同时支持排序和去重）。
契约保持：不会破坏原始类的行为约定。

三、泛型与注解的高级应用

3.1 泛型边界的精确控制

泛型边界（Bounded Type Parameters）可限制类型参数的范围，提升类型安全性。例如，实现一个比较器工厂，仅接受实现了Comparable的类：

public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
    return (a, b) -> a.compareTo(b);
}

此处? super T表示允许比较T或其父类的实例，符合PECS原则（Producer Extends, Consumer Super）。

3.2 自定义注解的元编程

注解处理器可实现编译时或运行时的代码检查。例如，定义一个检查非空参数的注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.PARAMETER)
public @interface NonNull {
}
// 运行时检查（通过反射）
public void process(@NonNull String input) {
    if (input == null) {
        throw new NullPointerException("参数不能为null");
    }
    // 业务逻辑...
}

结合AOP框架（如Spring AOP），可进一步将非空检查逻辑从业务代码中解耦。

四、并发编程的实用模式

4.1 不可变对象的线程安全

不可变对象（如String、Integer）无需同步即可安全用于多线程环境。例如，自定义一个不可变的点类：

public final class ImmutablePoint {
    private final int x;
    private final int y;
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() { return x; }
    public int getY() { return y; }
}

由于所有字段均为final且无方法修改状态，多个线程可安全共享其实例。

4.2 并发工具类的选择

java.util.concurrent包提供了丰富的并发工具：

CountDownLatch：等待多个线程完成。
CyclicBarrier：线程间同步点。
Semaphore：限制资源访问数量。

例如，使用CountDownLatch实现多线程任务协调：

ExecutorService executor = Executors.newFixedThreadPool(3);
CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    executor.submit(() -> {
        try {
            // 模拟耗时任务
            Thread.sleep(1000);
        } finally {
            latch.countDown();
        }
    });
}
latch.await(); // 阻塞直到所有任务完成
executor.shutdown();

五、异常处理的最佳实践

5.1 异常的层次化设计

自定义异常应继承自适当的父类（如IOException、RuntimeException），并包含有意义的错误信息。例如：

public class InvalidInputException extends RuntimeException {
    public InvalidInputException(String message) {
        super(message);
    }
}
// 使用示例
public void validateInput(String input) {
    if (input == null || input.isEmpty()) {
        throw new InvalidInputException("输入不能为空");
    }
}

5.2 异常转译的链式传递

捕获底层异常后，可包装为更高层次的异常重新抛出：

try {
    // 可能抛出IOException的代码
} catch (IOException e) {
    throw new BusinessException("数据处理失败", e); // 保留原始异常作为cause
}

这种方式既保留了堆栈信息，又提供了业务层面的错误描述。

六、总结与行动建议

《Effective Java 中文第三版》的核心价值在于提供可验证的最佳实践，而非理论说教。开发者可通过以下步骤落地优化：

代码审查：检查方法是否包含参数校验和不可变返回。
类重构：将继承关系替换为组合模式。
泛型升级：为集合类添加类型边界。
并发测试：使用JMH（Java Microbenchmark Harness）验证多线程性能。

通过持续实践书中的原则，开发者可显著提升代码质量，减少后期维护成本。正如Joshua Bloch所言：“优秀的代码是写出来的，更是改出来的。”

Effective Java 中文第三版：方法与类的深度优化指南