如何为已有类添加方法实现x.add(y)调用？除继承外还有其他方案吗？

嘿，这个问题很典型！首先得纠正一个小误区：Java里的Integer类是被final关键字修饰的，你没办法直接继承它来扩展方法——这是Java为了保证不可变类的安全性和性能做的设计，所以你之前想到的继承方案其实走不通哦😅

下面给你几个可行的替代方案，适配不同的场景：

1. 静态工具类（最简单实用） #

写一个工具类封装加法逻辑，这是Java里最常用的扩展现有类功能的方式：

public class IntegerUtils {
    // 封装加法逻辑，可添加空值判断避免NPE
    public static Integer add(Integer x, Integer y) {
        if (x == null || y == null) {
            throw new IllegalArgumentException("参数不能为null");
        }
        return x + y;
    }
}

调用的时候直接用IntegerUtils.add(x, y)，虽然不是x.add(y)的形式，但胜在简单直接，而且泛型场景下也能轻松适配——你可以把工具类做成泛型的，或者针对不同泛型类型写重载方法。

2. 自定义包装类（实现x.add(y)的调用形式） #

如果你一定要x.add(y)这种面向对象的调用方式，可以自己写一个包装类，内部委托给Integer实例：

public class MyInteger {
    private final Integer innerValue;

    // 构造方法，接收原始Integer
    public MyInteger(Integer value) {
        this.innerValue = value;
    }

    // 实现add方法
    public Integer add(Integer y) {
        if (innerValue == null || y == null) {
            throw new IllegalArgumentException("参数不能为null");
        }
        return innerValue + y;
    }

    // 可选：添加获取原始Integer的方法
    public Integer getValue() {
        return innerValue;
    }

    // 重写toString、equals等方法，让包装类更贴近Integer的行为
    @Override
    public String toString() {
        return innerValue != null ? innerValue.toString() : "null";
    }
}

使用的时候需要把原始Integer包装一下：

MyInteger x = new MyInteger(5);
Integer result = x.add(3); // 返回8

这种方式完全满足你要的调用形式，而且你还可以根据需求扩展更多方法。

3. 泛型场景的适配方案 #

既然你提到最初是因为泛型类的需求，那更推荐定义一个通用的Addable接口，让你的泛型代码依赖这个接口而非具体的Integer类：

// 定义通用的可加法接口
public interface Addable<T> {
    T add(T other);
}

// 为Integer实现这个接口的适配器类
public class IntegerAddable implements Addable<Integer> {
    private final Integer value;

    public IntegerAddable(Integer value) {
        this.value = value;
    }

    @Override
    public Integer add(Integer other) {
        if (value == null || other == null) {
            throw new IllegalArgumentException("参数不能为null");
        }
        return value + other;
    }
}

之后你的泛型类就可以基于Addable<T>来编写，比如：

public class GenericCalculator<T extends Addable<T>> {
    public T calculateSum(T a, T b) {
        return a.add(b);
    }
}

这样不管是Integer还是其他需要加法操作的类型，只要实现了Addable接口，就能被泛型类兼容，扩展性非常好。

额外提一句：如果用Kotlin的话 #

如果你的项目可以用Kotlin，那事情会简单很多——Kotlin支持扩展方法，直接给Int（或者Integer）加add方法：

fun Int.add(other: Int): Int {
    return this + other
}

调用的时候直接5.add(3)，完美实现你想要的形式，但这仅限于Kotlin环境哦。

内容的提问来源于stack exchange，提问作者Maristo-Tero