如何在构造方法中创建后续可用数组？矩阵类指定类型初始化二维数组

嘿，我来帮你解决这两个Java相关的问题！

这事儿其实挺直接的——你只需要在构造方法里完成数组的实例化，然后把它赋值给类的成员变量就行，这样类里的其他方法后续就能直接调用这个数组了。举个实际的例子：

public class MyClass {
    // 先声明一个成员数组变量，留着后续用
    private int[] myArray;

    // 在构造方法里初始化数组
    public MyClass(int size) {
        // 第一步：创建指定大小的数组实例
        myArray = new int[size];
        // 要是需要的话，还可以顺便给数组元素赋初始值，比如这里每个元素设为索引的2倍
        for (int i = 0; i < size; i++) {
            myArray[i] = i * 2;
        }
    }

    // 后续用这个数组的方法，比如打印出来
    public void printArray() {
        for (int num : myArray) {
            System.out.println(num);
        }
    }
}

核心逻辑就是在构造方法里用new 数组类型[长度]创建数组，然后把它绑定到类的成员变量上，这样整个实例生命周期里都能访问到这个数组啦。

你原来的代码有个小问题：成员变量是int[][] matrix，但你想支持int、double、float三种类型，这单一类型的变量肯定兜不住啊。这里我推荐用泛型类来实现，既能保证类型安全，又能灵活适配不同的数据类型（不过要注意，Java的泛型不支持直接用基本类型，得用对应的包装类，比如Integer、Double、Float；如果非要用基本类型数组，后面我也给你另一种方案）。

先看泛型的优雅方案：

// 把Matrix改成泛型类，T就是你要的矩阵元素类型
import java.lang.reflect.Array;

public class Matrix<T> {
    private T[][] matrix;

    // 构造方法：接收行数、列数，还有元素类型的Class对象（因为泛型类型擦除，得靠它创建数组）
    @SuppressWarnings("unchecked")
    public Matrix(int rows, int cols, Class<T> type) {
        // 用Array.newInstance来创建指定类型的二维数组，然后强转成T[][]
        matrix = (T[][]) Array.newInstance(type, rows, cols);
    }

    // 提供获取矩阵的方法，后续用的时候直接调这个
    public T[][] getMatrix() {
        return matrix;
    }

    // 示例：给矩阵某个位置赋值的方法
    public void setValue(int row, int col, T value) {
        matrix[row][col] = value;
    }

    // 示例：打印矩阵的方法
    public void printMatrix() {
        for (T[] row : matrix) {
            for (T elem : row) {
                System.out.print(elem + " ");
            }
            System.out.println();
        }
    }

    // 测试一下看看效果
    public static void main(String[] args) {
        // 创建一个3x3的Integer类型矩阵
        Matrix<Integer> intMatrix = new Matrix<>(3, 3, Integer.class);
        intMatrix.setValue(0, 0, 1);
        intMatrix.setValue(1, 1, 2);
        intMatrix.printMatrix();

        // 再整个2x2的Double类型矩阵
        Matrix<Double> doubleMatrix = new Matrix<>(2, 2, Double.class);
        doubleMatrix.setValue(0, 1, 3.14);
        doubleMatrix.printMatrix();
    }
}

如果你非要直接用基本类型的数组（比如int[][]而不是Integer[][]），那可以给每种类型单独定义成员变量，通过switch来初始化，就是这样：

public class Matrix {
    private int[][] intMatrix;
    private double[][] doubleMatrix;
    private float[][] floatMatrix;
    private String currentType; // 记一下当前矩阵是什么类型

    public Matrix(int rows, int cols, String type) {
        this.currentType = type;
        switch (type) {
            case "int":
                intMatrix = new int[rows][cols];
                break;
            case "double":
                doubleMatrix = new double[rows][cols];
                break;
            case "float":
            default:
                floatMatrix = new float[rows][cols];
                break;
        }
    }

    // 获取矩阵的时候得判断类型再返回，用的时候要强制转换
    public Object getMatrix() {
        switch (currentType) {
            case "int":
                return intMatrix;
            case "double":
                return doubleMatrix;
            case "float":
            default:
                return floatMatrix;
        }
    }
}

不过这种方式每次用都要强制转换，而且容易出错，所以还是泛型的方案更靠谱哦。

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