Java编写一个类，其main方法实现，自动生成一个5阶方阵对角线上元素为1，其他元素均为0

在Java中，你可以创建一个二维数组来表示一个5阶的方阵，并在对角线上的元素设置为1，其余元素设为0。以下是一个简单的`Main`类示例：

public class Main {
    public static void main(String[] args) {
        int[][] matrix = new int[5][5]; // 创建一个5x5的二维数组

        // 自动填充对角线元素为1，其余为0
        for (int i = 0; i < 5; i++) {
            matrix[i][i] = 1; // 对角线元素
        }

        // 打印矩阵
        for (int[] row : matrix) {
            for (int element : row) {
                System.out.print(element + " ");
            }
            System.out.println(); // 每行打印后换行
        }
    }
}

当你运行这个程序，它将输出一个5阶的方阵，其中对角线上的元素都是1，其它位置都是0。

相关问题

用java编写一个矩阵类，其中封装有一个数组，含求所有元素和的方法，另有一个方阵类，继承矩阵类，构造时要求数据的行、列相同，并提供求主对角线元素和的方法，用随机数构建6*6方阵，输出方阵，并求所有元素和、主对角线元素和

首先，我们创建一个基础的矩阵类Matrix，它包含一个二维数组以及求和的方法：

public class Matrix {
    private int[][] data;

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

    // 求矩阵所有元素之和
    public int sumAllElements() {
        int sum = 0;
        for (int[] row : data) {
            for (int element : row) {
                sum += element;
            }
        }
        return sum;
    }

    // 用于演示如何添加，这里不做实现
    public void setElement(int row, int col, int value) {
        data[row][col] = value;
    }
}

然后，我们创建一个继承自Matrix的方阵类SquareMatrix，增加求主对角线元素和的方法：

public class SquareMatrix extends Matrix {
    public SquareMatrix(int size) {
        super(size, size);
    }

    // 求主对角线元素之和
    public int sumDiagonalElements() {
        int sum = 0;
        for (int i = 0; i < size; i++) {
            sum += data[i][i];
        }
        return sum;
    }
}

现在我们可以用随机数构建一个6x6的方阵并打印结果：

public static void main(String[] args) {
    Random rand = new Random();
    SquareMatrix squareMatrix = new SquareMatrix(6);

    for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 6; j++) {
            squareMatrix.setElement(i, j, rand.nextInt(100)); // 生成0到99之间的随机整数
        }
    }

    System.out.println("Original Matrix:");
    for (int[] row : squareMatrix.data) {
        for (int element : row) {
            System.out.print(element + "\t");
        }
        System.out.println();
    }

    // 输出所有元素和
    int allElementsSum = squareMatrix.sumAllElements();
    System.out.println("\nSum of all elements: " + allElementsSum);

    // 输出主对角线元素和
    int diagonalElementsSum = squareMatrix.sumDiagonalElements();
    System.out.println("\nSum of diagonal elements: " + diagonalElementsSum);
}

在JAVA中，编写程序，提示用户输入一个方阵的长度，随机地在该矩阵中填入0和1.打印这个矩阵，然后找出整行、整列或者对角线都是0或1的行、列和对角线。给出完整代码。

在Java中，可以创建一个程序来完成这样的任务。首先，我们需要获取矩阵的大小，然后生成一个指定大小的矩阵，其中元素随机为0或1。接着遍历矩阵，找到全0或全1的行、列和对角线。以下是完整的代码实现：

import java.util.Scanner;

class Matrix {
    int rows;
    int cols;
    double[][] matrix;

    public Matrix(int size) {
        this.rows = size;
        this.cols = size;
        matrix = new double[rows][cols];
        initializeMatrix();
    }

    private void initializeMatrix() {
        Scanner scanner = new Scanner(System.in);
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                matrix[i][j] = Math.random() < 0.5 ? 0 : 1; // 随机分配0或1
            }
        }
        printMatrix();
        findZeroOneRowsColumnsDiagonals();
    }

    private void printMatrix() {
        System.out.println("矩阵:");
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }

    private boolean isRowOrColumnAllZeroOrOne(int row, int col) {
        for (int i = 0; i < cols; i++) {
            if (matrix[row][i] != (col % 2 == 0 ? 0 : 1)) {
                return false;
            }
        }
        for (int j = 0; j < rows; j++) {
            if (matrix[j][col] != (row % 2 == 0 ? 0 : 1)) {
                return false;
            }
        }
        return true;
    }

    private boolean isMainDiagonalAllZeroOrOne() {
        for (int i = 0; i < rows && i < cols; i++) {
            if (matrix[i][i] != (i % 2 == 0 ? 0 : 1)) {
                return false;
            }
        }
        return true;
    }

    private void findZeroOneRowsColumnsDiagonals() {
        int zeroOneRows = 0, zeroOneColumns = 0;
        System.out.println("\n全0或1的行:\n");
        for (int i = 0; i < rows; i++) {
            if (isRowOrColumnAllZeroOrOne(i, -1)) {
                System.out.println("行 " + (i+1) + ": 全0或1");
                zeroOneRows++;
            }
        }
        System.out.println("全0或1的列:\n");
        for (int i = 0; i < cols; i++) {
            if (isRowOrColumnAllZeroOrOne(-1, i)) {
                System.out.println("列 " + (i+1) + ": 全0或1");
                zeroOneColumns++;
            }
        }
        System.out.println("主对角线全0或1: " + (isMainDiagonalAllZeroOrOne() ? "有" : "无"));
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入矩阵的长度: ");
        int size = input.nextInt();
        Matrix matrixObj = new Matrix(size);
    }
}

在上述代码中，我们首先定义了一个`Matrix`类，包含了生成矩阵、打印矩阵以及查找全0或1行、列和主对角线的方法。在`main`方法中，从用户那里获取矩阵的大小并实例化`Matrix`对象。