Java中Function接口处理可变参数函数：通用适配策略与实践

public void init(Function<Object, Double> function, Object... args){
    // ...
    // this.data[i][j] = function.apply(args); // 编译错误：incompatible types: Object[] cannot be converted to Object
    // ...
}

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[]作为参数并返回Double的函数来初始化矩阵。
     *
     * @param function 用于生成矩阵元素的函数，其唯一参数为Object[]。
     * @param args     传递给函数的实际参数数组。
     */
    public void init(Function<Object[], Double> function, Object... args) {
        for (int i = 0; i < this.rows; i++) {
            for (int j = 0; j < this.cols; j++) {
                // 将可变参数args作为Object[]传递给函数
                this.data[i][j] = function.apply(args);
            }
        }
    }

    // 示例：打印矩阵
    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();
        }
    }

    // ... 其他Matrix方法
}

import java.util.Random;

public class FunctionExamples {

    /**
     * 一个接受两个整数参数并返回其乘积的函数。
     * 参数通过Object[]数组传入。
     *
     * @param args 包含两个整数的Object数组。
     * @return 两个整数的乘积，作为Double返回。
     * @throws ClassCastException 如果参数类型不正确。
     * @throws IndexOutOfBoundsException 如果参数数量不足。
     */
    public static Double multiply(Object[] args) {
        // 确保参数数量和类型正确
        if (args == null || args.length < 2) {
            throw new IllegalArgumentException("Expected two integer arguments for multiply function.");
        }
        int a = (int) args[0]; // 显式类型转换
        int b = (int) args[1]; // 显式类型转换
        return (double) a * b;
    }

    /**
     * 一个接受一个最小值和一个最大值，并返回一个随机数的函数。
     * 参数通过Object[]数组传入。
     *
     * @param args 包含最小值(double)和最大值(double)的Object数组。
     * @return 范围内的随机数，作为Double返回。
     */
    public static Double getRandomNumber(Object[] args) {
        if (args == null || args.length < 2) {
            throw new IllegalArgumentException("Expected min and max double arguments for getRandomNumber function.");
        }
        double min = (double) args[0];
        double max = (double) args[1];
        Random rand = new Random();
        return min + (max - min) * rand.nextDouble();
    }

    /**
     * 一个不接受任何参数，总是返回固定值的函数。
     *
     * @param args 空的Object数组。
     * @return 固定值100.0。
     */
    public static Double getConstantValue(Object[] args) {
        // 对于无参数函数，可以忽略args
        return 100.0;
    }
}

public class MatrixInitializer {
    public static void main(String[] args) {
        Matrix matrix = new Matrix(3, 3);

        System.out.println("Initializing matrix with multiply function (2, 3):");
        // 使用multiply函数，传入参数2和3
        matrix.init(FunctionExamples::multiply, 2, 3);
        matrix.print();
        // 预期输出:
        // 6.00 6.00 6.00
        // 6.00 6.00 6.00
        // 6.00 6.00 6.00

        System.out.println("\nInitializing matrix with random number function (10.0, 20.0):");
        // 使用getRandomNumber函数，传入参数10.0和20.0
        matrix.init(FunctionExamples::getRandomNumber, 10.0, 20.0);
        matrix.print();
        // 预期输出: 10.0到20.0之间的随机数

        System.out.println("\nInitializing matrix with constant value function:");
        // 使用getConstantValue函数，不传入任何额外参数
        matrix.init(FunctionExamples::getConstantValue);
        matrix.print();
        // 预期输出:
        // 100.00 100.00 100.00
        // 100.00 100.00 100.00
        // 100.00 100.00 100.00
    }
}