用Java编写一个代码能够让用户输入指定阶数的矩阵，实现矩阵的加、减、乘、求行列式等运算。

当然可以！以下是一个示例代码，可以让用户输入指定阶数的矩阵，并实现矩阵的加、减、乘、求行列式等运算。

import java.util.Scanner;

public class MatrixOperations {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入矩阵的阶数：");
        int n = scanner.nextInt();

        int[][] matrixA = new int[n][n];
        int[][] matrixB = new int[n][n];

        // 输入矩阵A
        System.out.println("请输入矩阵A的元素：");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrixA[i][j] = scanner.nextInt();
            }
        }

        // 输入矩阵B
        System.out.println("请输入矩阵B的元素：");
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                matrixB[i][j] = scanner.nextInt();
            }
        }

        // 矩阵加法
        int[][] sumMatrix = addMatrix(matrixA, matrixB);
        System.out.println("矩阵A + 矩阵B 的结果为：");
        printMatrix(sumMatrix);

        // 矩阵减法
        int[][] diffMatrix = subtractMatrix(matrixA, matrixB);
        System.out.println("矩阵A - 矩阵B 的结果为：");
        printMatrix(diffMatrix);

        // 矩阵乘法
        int[][] productMatrix = multiplyMatrix(matrixA, matrixB);
        System.out.println("矩阵A * 矩阵B 的结果为：");
        printMatrix(productMatrix);

        // 行列式
        int determinantA = calculateDeterminant(matrixA);
        int determinantB = calculateDeterminant(matrixB);
        System.out.println("矩阵A的行列式为：" + determinantA);
        System.out.println("矩阵B的行列式为：" + determinantB);
    }

    // 矩阵加法
    public static int[][] addMatrix(int[][] matrixA, int[][] matrixB) {
        int n = matrixA.length;
        int[][] result = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = matrixA[i][j] + matrixB[i][j];
            }
        }
        return result;
    }

    // 矩阵减法
    public static int[][] subtractMatrix(int[][] matrixA, int[][] matrixB) {
        int n = matrixA.length;
        int[][] result = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = matrixA[i][j] - matrixB[i][j];
            }
        }
        return result;
    }

    // 矩阵乘法
    public static int[][] multiplyMatrix(int[][] matrixA, int[][] matrixB) {
        int n = matrixA.length;
        int[][] result = new int[n][n];

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < n; k++) {
                    result[i][j] += matrixA[i][k] * matrixB[k][j];
                }
            }
        }
        return result;
    }

    // 计算矩阵的行列式
    public static int calculateDeterminant(int[][] matrix) {
        int n = matrix.length;
        int determinant = 0;

        if (n == 1) {
            determinant = matrix[0][0];
        } else if (n == 2) {
            determinant = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
        } else {
            for (int i = 0; i < n; i++) {
                determinant += Math.pow(-1, i) * matrix[0][i] * calculateDeterminant(getSubMatrix(matrix, 0, i));
            }
        }

        return determinant;
    }

    // 获取矩阵的子矩阵（去掉指定行和列）
    public static int[][] getSubMatrix(int[][] matrix, int row, int col) {
        int n = matrix.length;
        int[][] subMatrix = new int[n - 1][n - 1];
        int rowIndex = 0;
        int colIndex;

        for (int i = 0; i < n; i++) {
            if (i == row) {
                continue;
            }
            colIndex = 0;
            for (int j = 0; j < n; j++) {
                if (j == col) {
                    continue;
                }
                subMatrix[rowIndex][colIndex] = matrix[i][j];
                colIndex++;
            }
            rowIndex++;
        }

        return subMatrix;
    }

    // 打印矩阵
    public static void printMatrix(int[][] matrix) {
        int n = matrix.length;

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

这个示例代码使用了多个方法来实现不同的矩阵运算，包括矩阵加法、矩阵减法、矩阵乘法以及行列式的计算。用户可以根据需要输入矩阵的阶数和元素，程序会计算并输出相应的结果。请注意，这个示例代码仅展示了基本的矩阵运算，可能不够完善或高效，你可以根据实际需求进行修改和优化。