用Java实现矩阵的基本运算（矩阵与数字相加，矩阵与矩阵相加，矩阵矩阵相乘，矩阵与数字相乘）附有详细代码以及注释

主类中的代码：

package packagename01;
import java.util.Scanner;
public class MainClass {
    public static Scanner sc=new Scanner(System.in);
    public static void main(String[] args) {
        int rowCount,colCount;
        System.out.println("输入矩阵行列数");
        rowCount=sc.nextInt();
        colCount=sc.nextInt();
//创建1个rowCount×colCount的矩阵,矩阵所有元素初始化为0
        Matrix matA=new Matrix(rowCount,colCount);
        MainClass.inputMatrix(matA);
        System.out.println("矩阵A=\n"+matA);
        Matrix matB=new Matrix(rowCount,colCount);
        MainClass.inputMatrix(matB);
        System.out.println("矩阵B=\n"+matB);
        System.out.println("运算结果如下:");
//执行矩阵相加运算
        Matrix matC=matA.plus(matB);
        System.out.println("C=\n"+matC);
//修改matA的第2行，第2列的那个元素
        matA.data[1][1]=89.4;
//执行矩阵与一个数相加的运算，即矩阵的所有元素都加上这个数
        Matrix matD=matA.plus(5.6);
        System.out.println("D=\n"+matD);
//执行矩阵和1个数相乘，即矩阵的所有元素都乘上这个数
        Matrix matF=matA.multiply(3.4);
        System.out.println("F=\n"+matF);
//求转置矩阵
        Matrix matG=matA.transpose();
        System.out.println("G=\n"+matG);
//执行矩阵乘法，不清楚矩阵乘法的真正含义，请参考线性代数教材。
        Matrix matE=matA.multiply(matG);
//按[[1,2,3],[4,5,6]]类似格式输出矩阵，这里的逗号都是英文逗号
        System.out.println("E=\n"+matE);
        MainClass.sc.close();
    }
    private static void inputMatrix(Matrix mat) {
        int rowCount=mat.getRowCount();
        int colCount=mat.getColCount();
        System.out.println("输入"+rowCount+"×"+colCount+"矩阵");
        for(int i=0;i<rowCount;i++) {
            for(int j=0;j<colCount;j++) {
                System.out.print("["+i+"]["+j+"]=");
                mat.data[i][j]=sc.nextDouble();
            }
        }
    }
}

副类中的代码：

package packagename01;

public class Matrix {
    //定义矩阵的行数(RowCount)
    int RowCount;
    //定义矩阵的列数(ColCount)
    int ColCount;
    double [][] data = null;   //定义用来储矩阵的二维数组
    public Matrix(int rowCount, int colCount) {
        RowCount = rowCount;
        ColCount = colCount;
        data = new double[RowCount][ColCount];  //为数组申请空间
    }
    //设置矩阵的行数
    public void setRowCount(int rowCount) {
        RowCount = rowCount;
    }
    //返回矩阵的行数
    public int getRowCount() {
        return RowCount;
    }
    //返回矩阵的列数
    public int getColCount() {
        return ColCount;
    }
    //设置矩阵的列数
   public void setColCount(int colCount) {
        ColCount = colCount;
    }


    //执行矩阵相加运算
    public Matrix plus(Matrix b)
    {
        //判断两个矩阵是否满足相加的条件
        if((RowCount!=b.RowCount)||(ColCount!=b.ColCount)){
            System.out.println("A不能加B");
            System.exit(1);
        }
        Matrix tmp=new Matrix(RowCount,ColCount);  //创建临时对象，将两个矩阵相加后得到的新矩阵存储到tmp的二维数组中
        //用双层循环遍历矩阵，完成矩阵的相加操作
        for(int i=0;i<RowCount;i++)
            for(int j=0;j<ColCount;j++)
                tmp.data[i][j]=data[i][j]+b.data[i][j];
        return tmp;    //返回临时对象
    }
    //执行矩阵与一个数相加的运算，即矩阵的所有元素都加上这个数
    public Matrix plus(double b)
    {
        //创建临时对象，将矩阵与数字相加得到的新矩阵存储到tmp的二维数组中
        Matrix tmp=new Matrix(RowCount,ColCount);
        for(int i=0;i<RowCount;i++)
            for(int j=0;j<ColCount;j++)
                tmp.data[i][j]=data[i][j]+b;  //基本的加法运算
        return tmp;  //返回临时对象
    }
    //执行矩阵和1个数相乘，即矩阵的所有元素都乘上这个数
    public Matrix multiply(double b)
    {
        Matrix tmp=new Matrix(RowCount,ColCount);  //创建临时对象，将矩阵与数字相乘得到的新矩阵存储到tmp的二维数组中
        for(int i=0;i<RowCount;i++)
            for(int j=0;j<ColCount;j++)
                tmp.data[i][j]=data[i][j]*b;
        return tmp;   //返回临时对象
    }
    //执行矩阵乘法，不清楚矩阵乘法的真正含义，请参考线性代数教材
    public Matrix multiply(Matrix b)
    {
        if(ColCount!=b.RowCount){
            System.out.println("A cannot times B");
            System.exit(1);
        }
        Matrix tmp=new Matrix(RowCount,b.ColCount);   //创建临时对象，将矩阵与矩阵相乘得到的新矩阵存储到tmp的二维数组中
        for(int i=0;i<RowCount;i++)
            for(int j=0;j<b.ColCount;j++){
                tmp.data[i][j]=0;
                for(int k=0;k<ColCount;k++)
                    tmp.data[i][j]+=data[i][k]*b.data[k][j];
            }
        return tmp;   //返回临时对象
    }
    //矩阵转置操作(将data[j][i] = data[i][j]即可)
    public Matrix transpose()
    {
        Matrix tmp=new Matrix(RowCount,ColCount);  //创建临时对象，将转置得到的新矩阵存储到tmp的二维数组中
        for (int i = 0;i < data.length;i++)
        {
            for (int j = 0;j < data[i].length;j++)
            {
                tmp.data[j][i] = data[i][j];
            }
        }
        return tmp;   // 返回临时对象
    }

    //定义String toString方法，来控制输出结果的格式与内容
    //将对象及其他转换成字符串的形式表达
    public String toString()
    {
        String str = "";
        for (int i = 0;i < data.length;i++)
        {
            for (int j = 0;j < data[i].length;j++)
            {
                str += this.data[i][j];
                if (j < data[i].length)
                {
                    str += " ";
                }
                if (j == data[i].length-1)
                {
                    str += "\n";
                }
            }
        }
        return str;      //返回特定的字符串
    }
}

运行结果：

输入矩阵行列数
3
3
输入3×3矩阵
[0][0]=1
[0][1]=1
[0][2]=1
[1][0]=1
[1][1]=1
[1][2]=1
[2][0]=1
[2][1]=1
[2][2]=1
矩阵A=
1.0 1.0 1.0 
1.0 1.0 1.0 
1.0 1.0 1.0 

输入3×3矩阵
[0][0]=2
[0][1]=2
[0][2]=2
[1][0]=2
[1][1]=2
[1][2]=2
[2][0]=2
[2][1]=2
[2][2]=2
矩阵B=
2.0 2.0 2.0 
2.0 2.0 2.0 
2.0 2.0 2.0 

运算结果如下:
C=
3.0 3.0 3.0 
3.0 3.0 3.0 
3.0 3.0 3.0 

D=
6.6 6.6 6.6 
6.6 95.0 6.6 
6.6 6.6 6.6 

F=
3.4 3.4 3.4 
3.4 303.96000000000004 3.4 
3.4 3.4 3.4 

G=
1.0 1.0 1.0 
1.0 89.4 1.0 
1.0 1.0 1.0 

E=
3.0 91.4 3.0 
91.4 7994.360000000001 91.4 
3.0 91.4 3.0