Java泛型矩阵加法实现难题：如何优雅处理Number类型运算？

你的核心痛点在于Java泛型擦除+不支持运算符重载，导致无法直接对Number子类执行算术操作。下面是一套解耦且优雅的解决方案，不用硬编码判断类型，也不用放弃泛型。

核心思路：引入数值运算器接口 #

把数值的加减乘等运算逻辑从Matrix类中抽离，定义一个专用的运算器接口，让每种Number子类对应自己的运算实现，矩阵类只负责调用运算器完成元素级操作，完全符合开闭原则。

1. 定义NumberOperator接口 #

public interface NumberOperator<T extends Number & Comparable<? super T>> {
    T add(T a, T b);
    T multiply(T a, T b);
    // 可扩展其他运算：减、除、取模等
}

2. 为常用数值类型实现运算器 #

比如Integer和Double的实现：

public class IntegerOperator implements NumberOperator<Integer> {
    @Override
    public Integer add(Integer a, Integer b) {
        return a + b;
    }

    @Override
    public Integer multiply(Integer a, Integer b) {
        return a * b;
    }
}

public class DoubleOperator implements NumberOperator<Double> {
    @Override
    public Double add(Double a, Double b) {
        return a + b;
    }

    @Override
    public Double multiply(Double a, Double b) {
        return a * b;
    }
}

3. 重构Matrix接口与DenseMatrix类 #

首先修正原接口的泛型约束（原M extends Matrix缺少类型参数，会导致类型不安全）：

public interface Matrix<T extends Number & Comparable<? super T>, L extends List<T>, M extends Matrix<T, L, M>> {
    M add(M matrix) throws MatrixException;
    M mul(M matrix) throws MatrixException;
}

然后修改DenseMatrix，让它持有对应的NumberOperator：

public class DenseMatrix<T extends Number & Comparable<? super T>, L extends List<T>> implements Matrix<T, L, DenseMatrix<T, L>> {
    private final NumberOperator<T> operator;
    private L rows; // 假设内部存储结构是行列表

    // 构造器传入运算器，确保类型匹配
    public DenseMatrix(L rows, NumberOperator<T> operator) {
        this.rows = rows;
        this.operator = operator;
    }

    @Override
    public DenseMatrix<T, L> add(DenseMatrix<T, L> matrix) throws MatrixException {
        // 先做矩阵维度校验，省略校验代码
        L resultRows = // 初始化自定义List实例
        for (int i = 0; i < rows.size(); i++) {
            T row1 = rows.get(i);
            T row2 = matrix.rows.get(i);
            // 逐元素调用运算器相加
            T resultRow = // 初始化行元素容器
            for (int j = 0; j < row1.size(); j++) {
                T val1 = row1.get(j);
                T val2 = row2.get(j);
                resultRow.set(j, operator.add(val1, val2));
            }
            resultRows.add(resultRow);
        }
        return new DenseMatrix<>(resultRows, operator);
    }

    // mul方法同理，调用operator.multiply即可
    @Override
    public DenseMatrix<T, L> mul(DenseMatrix<T, L> matrix) throws MatrixException {
        // 实现逻辑，使用operator.multiply完成元素运算
    }
}

4. 使用示例 #

// 创建Integer类型的矩阵
List<Integer> row1 = new MyList<>(List.of(1, 2));
List<Integer> row2 = new MyList<>(List.of(3, 4));
DenseMatrix<Integer, MyList<Integer>> mat1 = new DenseMatrix<>(new MyList<>(List.of(row1, row2)), new IntegerOperator());

// 同理创建mat2，执行加法
DenseMatrix<Integer, MyList<Integer>> sum = mat1.add(mat2);

额外优化：静态工厂方法简化创建 #

可以给DenseMatrix加静态工厂方法，隐藏运算器的细节：

public static DenseMatrix<Integer, MyList<Integer>> integerMatrix(MyList<MyList<Integer>> rows) {
    return new DenseMatrix<>(rows, new IntegerOperator());
}

public static DenseMatrix<Double, MyList<Double>> doubleMatrix(MyList<MyList<Double>> rows) {
    return new DenseMatrix<>(rows, new DoubleOperator());
}

// 使用时更简洁
var mat = DenseMatrix.integerMatrix(rows);

原设计的小调整建议 #

1. 原Matrix接口中M extends Matrix应补全类型参数M extends Matrix<T, L, M>，避免泛型类型丢失导致的编译警告或类型不安全。
2. 自定义的List类建议和JDK的List接口保持一致的方法签名，降低使用成本和出错概率。

这种方案的优势在于：

• 完全解耦矩阵逻辑和数值运算逻辑，新增Number子类时只需实现对应的NumberOperator，不用修改矩阵代码。
• 避免了大量instanceof判断，代码更简洁易维护。
• 保留了泛型的灵活性，同时保证类型安全。

内容的提问来源于stack exchange，提问作者Duo Zhang