Java Function接口与可变参数：统一Object[]输入的设计模式

public void init(Function<Object, Double> function, Object... args) {
    // ...
    this.data[i][j] = function.apply(args); // 编译时或运行时可能出错
    // ...
}

public static double multiplyFunc(Object[] args) {
    if (args == null || args.length < 2) {
        throw new IllegalArgumentException("Expected at least two arguments for multiplication.");
    }
    // 注意：这里没有进行try-catch，如果传入类型不符，将抛出ClassCastException
    int a = (int) args[0];
    int b = (int) args[1];
    return (double) a * b;
}

import java.util.Random;
import java.util.function.Function;

public class Matrix {
    private double[][] data;
    private int rows;
    private int cols;

    public Matrix(int rows, int cols) {
        this.rows = rows;
        this.cols = cols;
        this.data = new double[rows][cols];
    }

    /**
     * 使用一个接受Object[]数组作为参数的函数来初始化矩阵。
     *
     * @param initializer 一个函数，接受Object[]作为输入，返回一个Double。
     * @param args        传递给initializer函数的实际参数数组。
     */
    public void init(Function<Object[], Double> initializer, Object... args) {
        for (int i = 0; i < this.rows; i++) {
            for (int j = 0; j < this.cols; j++) {
                // 将行和列索引也作为参数传递，如果initializer需要的话
                Object[] fullArgs = new Object[args.length + 2];
                System.arraycopy(args, 0, fullArgs, 0, args.length);
                fullArgs[args.length] = i; // 额外添加行索引
                fullArgs[args.length + 1] = j; // 额外添加列索引

                this.data[i][j] = initializer.apply(fullArgs);
            }
        }
    }

    // 辅助方法：打印矩阵
    public void print() {
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.printf("%.2f ", data[i][j]);
            }
            System.out.println();
        }
    }

    // ----------------- 各种初始化函数示例 -----------------

    /**
     * 返回一个常量值。此函数不使用传入的args。
     */
    public static double constantFunc(Object[] args) {
        return 42.0;
    }

    /**
     * 返回两个整数的乘积。
     * args[0]: int a
     * args[1]: int b
     */
    public static double multiplyFunc(Object[] args) {
        if (args == null || args.length < 2) {
            throw new IllegalArgumentException("multiplyFunc: Expected at least two arguments (int, int).");
        }
        int a = (int) args[0];
        int b = (int) args[1];
        return (double) a * b;
    }

    /**
     * 生成一个指定范围内的随机数。
     * args[0]: double min
     * args[1]: double max
     * args[2]: Random instance (可选)
     */
    public static double randomRangeFunc(Object[] args) {
        if (args == null || args.length < 2) {
            throw new IllegalArgumentException("randomRangeFunc: Expected at least two arguments (double min, double max).");
        }
        double min = (double) args[0];
        double max = (double) args[1];
        Random rand = (args.length > 2 && args[2] instanceof Random) ? (Random) args[2] : new Random();
        return min + (max - min) * rand.nextDouble();
    }

    /**
     * 基于行和列索引计算值。
     * args[0]: int row (由init方法传入)
     * args[1]: int col (由init方法传入)
     */
    public static double indexedSumFunc(Object[] args) {
        if (args == null || args.length < 2) {
            throw new IllegalArgumentException("indexedSumFunc: Expected at least two arguments (int row, int col).");
        }
        int row = (int) args[0];
        int col = (int) args[1];
        return (double) (row + col);
    }

    public static void main(String[] args) {
        Matrix matrix1 = new Matrix(3, 3);
        System.out.println("--- Matrix 1: Constant Value ---");
        matrix1.init(Matrix::constantFunc); // 不需要额外参数
        matrix1.print();

        Matrix matrix2 = new Matrix(2, 4);
        System.out.println("\n--- Matrix 2: Multiplication (7 * 8) ---");
        matrix2.init(Matrix::multiplyFunc, 7, 8); // 传入两个参数
        matrix2.print();

        Matrix matrix3 = new Matrix(3, 2);
        System.out.println("\n--- Matrix 3: Random Numbers (10.0 to 20.0) ---");
        matrix3.init(Matrix::randomRangeFunc, 10.0, 20.0, new Random(123L)); // 传入三个参数，包括一个Random实例
        matrix3.print();

        Matrix matrix4 = new Matrix(4, 4);
        System.out.println("\n--- Matrix 4: Indexed Sum (row + col) ---");
        // 注意：这里的row和col是由init方法自动添加到fullArgs中的
        matrix4.init(Matrix::indexedSumFunc);
        matrix4.print();
    }
}