单例设计模式实现统计输入矩阵与随机矩阵乘法运算的执行时间

import java.util.Random;
import java.util.Scanner;

abstract class FatherClass {
    public static int count=0;

    public abstract int[][] matrix();

    

    //----------计算两种计算矩阵相乘的完成时间，这里为在抽象父类的普通方法--------
    public void calculateTime(){

        long startTime = System.currentTimeMillis();
        matrixMultiplication(matrix(),matrix());
        /*❗❗❗这里就是动态绑定机制了，将子类重写的matrix放到父类普通方法里从而对不同的子类在创建对象时，
        对不同的子类对象进行重写方法的调用，但是这里只需要写抽象方法matrix()就可以自动调用不同子类对象
        的重写matrix()方法
        */
        long endTime = System.currentTimeMillis();

        long interval = endTime -startTime;
        System.out.println("---------------此次程序完成的时间为:"+interval+"毫秒---------------");

    }
    
    //矩阵的乘法功能
    public int[][] matrixMultiplication(int[][] matrix1,int[][] matrix2){
        if (matrix1[0].length != matrix2.length){
            System.out.println("请注意矩阵的计算法则，要求输入第一个矩阵的列数等于第二个矩阵的行数,否则无法计算");
            System.out.println("请您重新运行一次矩阵");
        }
        int[][] receiveMatrix = new int[matrix1.length][matrix2[0].length];
        for (int i = 0; i < matrix1.length; i++) {

            for (int j = 0; j < matrix2[0].length; j++) {

                for (int k = 0; k < matrix1[0].length; k++) {
                    receiveMatrix[i][j] += matrix1[i][k] * matrix2[k][j];
                }
            }
        }
        System.out.println("矩阵的演算结果为：");
        showMatrix(receiveMatrix);
        return receiveMatrix;
    }
    
    //让矩阵显示出来
    public void showMatrix(int[][] matrix){
        System.out.println("矩阵：");
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.printf(matrix[i][j]+"\t");
            }
            System.out.println();
        }
    }

}

class SonClass1 extends FatherClass{

    //------------功能为用户输入的矩阵相乘-----------
    @Override
    public int[][] matrix() {
        Scanner scanner = new Scanner(System.in);
        System.out.printf("请输入要生成矩阵的行数m:");
        int matrixLine = scanner.nextInt();
        System.out.printf("请输入要生成矩阵的列数n:");
        int matrixColumns = scanner.nextInt();
        int[][] matrix = new int[matrixLine][matrixColumns];
        for (int i = 0; i < matrixLine; i++) {
            for (int j = 0; j < matrixColumns; j++) {
                System.out.printf("请输入第"+(i+1)+"行"+"第"+(j+1)+"列的数字：");
                matrix[i][j] = scanner.nextInt();
            }
        }
        showMatrix(matrix);
        return matrix;
    }
}

class SonClass2 extends FatherClass{

    //-------------功能为随机生成的矩阵进行相乘-------------
    @Override
    public int[][] matrix() {
        FatherClass.count ++;
        Random random = new Random();
        Random seed = new Random(10);
        int matrixLine = 2+random.nextInt(5);//避免生成行数和列数为0的情况，故基础数为+2，范围为[2,5]
        int matrixColumns = 2+seed.nextInt(5);//设置一个固定的随机种子
        if (count%2!=0){
            int[][] matrix = new int[matrixLine][matrixColumns];//直接在这里创建一个矩阵，不要写到外面，不然局部变量共享，会造成无法创建两个矩阵
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[0].length; j++) {
                    matrix[i][j] = random.nextInt(6);
                }
            }
            showMatrix(matrix);
            return matrix;//返回随机矩阵1
        }
        else {
            int[][] matrix = new int[matrixColumns][2+random.nextInt(5)];
            for (int i = 0; i < matrix.length; i++) {
                for (int j = 0; j < matrix[0].length; j++) {
                    matrix[i][j] = random.nextInt(10);
                }
            }
            showMatrix(matrix);
            return matrix;//返回随机矩阵2
        }

    }
}

class Test{
    public static void main(String[] args) {
        new SonClass1().calculateTime();

        new SonClass2().calculateTime();
    }
}

请输入要生成矩阵的行数m:3
请输入要生成矩阵的列数n:3
请输入第1行第1列的数字：3
请输入第1行第2列的数字：2
请输入第1行第3列的数字：1
请输入第2行第1列的数字：6
请输入第2行第2列的数字：2
请输入第2行第3列的数字：3
请输入第3行第1列的数字：1
请输入第3行第2列的数字：4
请输入第3行第3列的数字：3
矩阵：
3    2    1    
6    2    3    
1    4    3    
请输入要生成矩阵的行数m:3
请输入要生成矩阵的列数n:2
请输入第1行第1列的数字：5
请输入第1行第2列的数字：6
请输入第2行第1列的数字：4
请输入第2行第2列的数字：1
请输入第3行第1列的数字：3
请输入第3行第2列的数字：3
矩阵：
5    6    
4    1    
3    3    
矩阵的演算结果为：
矩阵：
26    23    
47    47    
30    19    
---------------此次程序完成的时间为:15657毫秒---------------
矩阵：
4    0    0    1    1    
2    2    2    1    5    
3    0    0    4    1    
2    0    5    2    4    
2    4    2    5    5    
5    2    5    0    0    
矩阵：
7    0    1    3    
7    9    4    4    
8    2    9    9    
9    0    2    8    
6    5    5    3    
矩阵的演算结果为：
矩阵：
43    5    11    23    
83    47    55    55    
63    5    16    44    
96    30    71    79    
133    65    71    95    
89    28    58    68    
---------------此次程序完成的时间为:3毫秒---------------