你声明了一个类Matrix，它封装了一个二维int数组，然而，在你的main()方法中，你接着创建了两个Matrix对象的二维数组（m1和m2），这实际上是没有意义的：要么你想封装这个二维数组，要么你不想，到底是哪个？
如果你真的想要用Matrix类封装一个包含随机数的二维数组（有意义），你可能应该这样做：

import java.util.Arrays;
import java.util.Random;

public class MatrixDemo {

    public static void main(String[] args) {
        final Random r = new Random();

        final Matrix matrix = new Matrix(4, 3);

        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 3; j++) {
                matrix.setMatrixValueAt(i, j, r.nextInt(20));
            }
        }
        System.out.println("Matrix: \n" + matrix);
    }

    public static class Matrix {
        // instance fields
        private int[][] matrixVals;

        public Matrix(int row, int column) {
            matrixVals = new int[row][column];
        }

        public void setMatrixValueAt(int row, int column, int value) {
            matrixVals[row][column] = value;
        }

        public int[][] getMatrixVals() {
            return matrixVals;
        }

        public String toString() {
            return Arrays.deepToString(matrixVals);
        }
    }

}

注意，我将Matrix声明为public static：这是因为我想在一个demo文件中完成所有的工作。如果你要进一步开发这个，把Matrix放到一个单独的文件中，Matrix.java放到合适的包中。在这种情况下，删除static关键字。

试试这个：

int[][] matrixVals = new int[4][3];

for(int i=0;i<4;i++) {

    for(int j=0;j<3;j++) { 

        matrixVals[i][j] = r.nextInt(20);

        System.out.print(matrixVals[i] [j] + "\t");
    }

    System.out.print("\n");
}

m2.setMatrixVals(matrixVals);

下面是我可能会如何处理它。

import java.util.Arrays;
import java.util.Random;

下面的代码非常简单，我只是选择了一些值来表示int数组的键大小，并使用一个流来填充它。

public class MatrixDemo {
    public static void main(String[] args) {
        Random r = new Random();
        int rows = 4;
        int cols = 3;
        int maxRowVal = 20;
        int maxColVal = 30;
        int[][] vals = r.ints(rows, 1, maxRowVal + 1)
                .mapToObj(rval -> r.ints(cols, 1, maxColVal + 1).toArray())
                .toArray(int[][]::new);
        
        // the following demonstrates the defensive capability. Changing the
        // int array does not alter the Matrix

        for (int[] v : vals) {
            System.out.println(Arrays.toString(v));
        }
        System.out.println("Matrix A:");
        Matrix m2 = new Matrix();
        m2.setMatrixVals(vals);
        vals[2][2] = 1000;
        System.out.println(vals[2][2]);
        for (int[] v : m2.getMatrixVals()) {
            System.out.println(Arrays.toString(v));
        }
    }
}

打印出这样的东西。

[24, 10, 30]
[7, 20, 8]
[29, 8, 27]
[11, 3, 3]
Matrix A:
1000
[24, 10, 30]
[7, 20, 8]
[29, 8, 27]
[11, 3, 3]

这里重要的是使用防御性复制，这样如果提供的数组在类外被更改，它不会更改Matrix array。矩阵值只能由setter更改。当检索值时，它们应该被再次复制，这样返回的副本，如果被修改，不会更改矩阵。
为了完成复制，我使用了clone()方法。它在对象克隆方面有它的问题，但当涉及到原语数组时，它工作得很好。
以这种方式制作防御性副本可能看起来代价高昂，但它被认为是一种很好的技术，可以帮助防止意外修改潜入代码。

class Matrix {
    // instance fields
    private int[][] matrixVals;

    public Matrix() {
       // create an empty Matrix
       // to be populated by using the setMatrixVals method
    }
    
    public Matrix(int[][] mVals) {
        matrixVals = copyValues(mVals);
    }

    public void setMatrixVals(int[][] mVals) {
        matrixVals = copyValues(mVals);
    }

    public int[][] getMatrixVals() {
        return copyValues(matrixVals);
    }
    
    public int getValueAt(int row, int col) {
        return matrixVals[row][col];
    }
    
    private int[][] copyValues(int[][] vals) {
        int[][] copy = new int[vals.length][vals[0].length];
        int i = 0;
        for(int[] v : vals) {
            copy[i++] = v.clone();
        }
        return copy;
    }
}

您可以添加的其他方法包括

• 从现有矩阵创建新矩阵。这可以是集的形式，也可以是不同的构造函数。
• 在行、列位置设置特定元素。
• 重写toString()以便可以打印对象。