Java实验五、数组与异常处理

新人猿86

于 2023-12-24 11:04:05 发布

阅读量928

点赞数 20

文章标签： java javascript

本文链接：https://blog.csdn.net/nianhao666/article/details/135178670

版权

实验目的：

掌握一维数组和二维数组的定义和初始化步骤；
进一步掌握toString()方法的应用；
掌握异常类的定义以及异常对象的实例化（new）、抛出（throw）、声明抛出（throws）、捕获（try…catch）等内容。

●参考学时：2学时

●基本要求：

编写实现一维数组的反转类“实验5.ArrayReverser”。该类包含一个int[]数组data、构造方法ArrayReverser(int[] data)、获取data数组的方法int[] getData()、设置data数组的方法void setData(int[] data)、将data数组内容转换为字符串的toString()方法以及用于反转data数组内容（即第一个元素和最后一个元素互换、第二个元素和倒数第二个元素互换…）的方法void reverse()。
编写ArrayReverser类的测试类实验5.ArrayTest。该类首先创建一个一维数组，并将其内容用随机数填充；其后利用上述一维数组创建ArrayReverser对象，并通过toString()方法查看初始数据；最后调用reverse()方法后再次调用toString()查看反转后的数据。
编写矩阵类实验5.Matrix。该类包括矩阵数据数组double data[][]，构造方法Matrix(int rows,int cols)、Matrix(double data[][])，获取某元素值的方法double getData(int row,int col)，设置某元素值的方法void setData(int row,int col,double value)，获取矩阵行数方法int getRows()，获取矩阵列数方法int getCols()，计算两个矩阵的乘积的方法Matrix multiply(Matrix m)以及equals()、toString()等内容。
编写测试类实验5.MatrixTest，测试Matrix类的正确性。
编写如下三个异常类，这些类只需要包含toString方法即可：
1. 1. 矩阵行数或列数非法异常类IllegalArgumentException
  2. 矩阵行号或列号非法异常类IllegalIndexException
  3. 矩阵无法相乘异常类MatrixMultiplicationException
完善Matrix类的相关方法，使其在不正确的调用情况下抛出适当的异常对象。
完善MatrixTest类，以测试异常类的定义和Matrix对异常类的应用是否有效。

●实验提示：

ArrayReverser(int[] data)构造方法和setData(int[] data)中尽量申请新的this.data数组，并把data形参内容复制到新数组中。
Matrix类是对现实生活中矩阵的抽象，而不是对二维数组的抽象。通过实例化该类对象，并赋与适当数据值，得到所需矩阵。
注意矩阵相乘方法的原型是Matrix multiply(Matrix m)，因为两个矩阵相乘的结果仍然是矩阵，而不是二维数组。
data不为空的前提下，矩阵行数是data.length值，列数是data[0].length值。
getData(row,col)方法的功能是得到矩阵的row行col列值。setData(row,col,value)方法的功能恰好相反，将矩阵的row行col列设置为value值。如getData(1,2)返回矩阵的1行2列值（一个double值），setData(2,3,1.5)将矩阵的2行3列值赋为1.5。
在Matrix类的所有构造方法中，如果行数或列数值小于1，或形参data为空，则抛出IllegalArgumentException异常；
在getData(…)和setData(…)方法中，如果行号或列号大于等于矩阵行数或列数，或小于0，则抛出IllegalIndexException异常；
在multiply(…)方法中，如果形参为空对象，或两个矩阵的行列数不满足矩阵相乘规则，则抛出MatrixMultiplicationException异常。
MatrixTest类中，通过预先设定的常数或键盘输入的值确定所要创建的两个矩阵的行列数。实例化矩阵对象之后，可生成一组随机数，或从键盘读入一组数，并循环调用setData(…)方法为矩阵某行某列赋值。建议采用随机数方式，键盘输入方式效率低，不利于程序的调试。
初始化矩阵对象之后，计算矩阵的乘积，并把结果通过toString方法的返回值输出到屏幕上，如某一2*3矩阵的输出结果为：

0,2,3

2,1,1

输出两个矩阵的乘积语句应该是：

System.out.println(m.multiply(n));

●测试案例：

表5.1 测试案例（仅用于编码测试）

编号	测试目的	输入或测试数据	期望结果
1	ArrayReverser构造方法	new ArrayReverser(null)	创建data数组长度为0的对象
2	ArrayReverser构造方法 getData方法	new ArrayReverser(data)	利用data数组内容创建ArrayReverser， getData()返回的数组内容应与原始data内容一样
3	ArrayReverser类setData方法	ar.setData(null)	ar对象data内容不变
4	ArrayReverser类setData方法	ar.setData(data)	ar对象data内容被形参data内容替换（数组长度也可能会发生变化）
5	ArrayReverser类reverse()方法	ar.reverse()	ar对象data内容被反转
6	ArrayReverser类toString()方法	ar.toString()	返回“3 6 1 5 7 34 65”形式字符串
7	Matrix类构造方法	new Matrix(2,3)	创建2*3矩阵，每项数据值全为0（数组被new后的默认值）
8	Matrix类构造方法	new Matrix(data)	创建以data数组为内容的矩阵对象
9	Matrix类构造方法	new Matrix(0,3)	抛出IllegalArgumentException异常（行数列数必须大于0）
10	Matrix类构造方法	new Matrix(null)	抛出IllegalArgumentException异常（参数不能为空）
11	获得列数	m.getCols()	返回列数（>0）
12	获得行数	m.getRows()	返回行数（>0）
13	getter方法	m.getData(0,0)	返回0行0列double值
14	setter方法	m.setData(0,0,10)	将0行0列值改为10
15	getter方法	m.getData(-1,0) m.getData(m.getRows(),0)	抛出IllegalIndexException异常（行号<0，行号>=行数）
16	setter方法	m.setData(0,-1) m.setData(0,m.getCols())	抛出IllegalIndexException异常（列号<0，列号>=列数）
17	multiply方法	m1.multiply(m2)	返回一个新矩阵，值为m1*m2
18	multiply方法	m1.multiply(null)	抛出MatrixMultiplicationException异常
19	multiply方法	m1.multiply(m2)，同时m1的列数不等于m2的行数	抛出MatrixMultiplicationException异常
20	toString方法	m1.toString()	返回“1 2\n3 4\n”形式的字符串

ArrayReverser类

package shiyan5;

import java.util.Arrays;

public class ArrayReverser {
    private int[] data;

    public ArrayReverser(int[] data) {
        this.data = data;
    }

    public int[] getData() {
        return data;
    }

    public void setData(int[] data) {
        this.data = data;
    }

    public int getLength(int[] data) {
        if (data == null) {
            return 0;
        }
        return data.length;
    }

    @Override
    public String toString() {
        String s = "";
        for (int i = 0; i < data.length; i++) {
            s += data[i] + "  ";
        }
        return s;
    }

    public void reverse() {
        for (int i = 0; i < data.length / 2; i++) {
            int t = data[i];
            data[i] = data[data.length - 1 - i];
            data[data.length - 1 - i] = t;
        }
        System.out.println(Arrays.toString(data));
    }
}

ArrayTest类

package shiyan5;

import java.util.Arrays;

public class ArrayTest {
    public static void main(String[] args) {
        int[] arr = new int[10];
        for (int i = 0; i < arr.length; i++) {
            int num = (int) (Math.random() * 20 + 1);
            arr[i] = num;
            for (int j = 0; j < i; j++) {
                if (num == arr[j]) {
                    i--;
                    break;
                }
            }
        }
        System.out.println("------------分割线1------------");
        ArrayReverser Arr1 = new ArrayReverser(null);
        System.out.println(Arr1.getLength(null));

        System.out.println("------------分割线2------------");
        ArrayReverser Arr2 = new ArrayReverser(arr);
        System.out.println("原始的数组:" + Arrays.toString(arr));
        System.out.println("get的数组:" + Arrays.toString(Arr2.getData()));

        System.out.println("------------分割线3------------");
        ArrayReverser ar = new ArrayReverser(arr);
        ar.setData(null);
        System.out.println(Arrays.toString(ar.getData()));

        System.out.println("------------分割线4------------");
        ar.setData(arr);
        System.out.println(Arrays.toString(ar.getData()));

        System.out.println("------------分割线5------------");
        ar.reverse();
        System.out.println("------------分割线6------------");
        ArrayReverser Arr = new ArrayReverser(arr);
        Arr.setData(arr);
        String s = Arr.toString();
        System.out.println(s);
    }
}

IllegalIndexException类

package shiyan5;

public class IllegalIndexException extends RuntimeException {

    public IllegalIndexException(String message) {
        super(message);
    }
}

MatrixMultiplicationException类

package shiyan5;

public class MatrixMultiplicationException extends RuntimeException {
    public MatrixMultiplicationException() {
    }
}

Matrix类

package shiyan5;

import java.util.Arrays;

public class Matrix {
    double[][] data;
    int rows;
    int cols;

    public Matrix(int rows, int cols) {
        if (rows < 1 || cols < 1) {
            throw new IllegalIndexException("行数列数必须大于0");
        }
        this.rows = rows;
        this.cols = cols;
        this.data = new double[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                this.data[i][j] = 0;
            }
        }
    }

    public Matrix(double[][] data) {
        if (data == null) {
            throw new IllegalIndexException("参数不能为空");
        }

        this.rows = data.length;
        this.cols = data[0].length;
        this.data = new double[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                this.data[i][j] = data[i][j];
            }
        }
    }

    public double getData(int rows, int cols) {
        if (rows < 0 || rows >= this.rows) {
            throw new IllegalIndexException("行数输入异常");
        }
        if (cols < 0 || cols >= this.cols) {
            throw new IllegalIndexException("列数输入异常");
        }
        return data[rows][cols];
    }

    public void setData(int rows, int cols, double value) throws IllegalArgumentException {
        if (rows < 0 || rows >= this.rows) {
            throw new IllegalIndexException("行数输入异常");
        }
        if (cols < 0 || cols >= this.cols) {
            throw new IllegalIndexException("列数输入异常");
        }
        data[rows][cols] = value;
    }

    public int getRows() {
        return this.rows;
    }

    public int getCols() {
        return this.cols;
    }

    public Matrix multiply(Matrix x) {
        if (x == null) {
            throw new MatrixMultiplicationException();
        }
        if (this.cols != x.rows) {
            throw new MatrixMultiplicationException();
        }
        Matrix result = new Matrix(this.rows, x.getCols());

        double num = 0;
        for (int i = 0; i < this.rows; i++) {
            for (int j = 0; j < x.cols; j++) {
                for (int k = 0; k < cols; k++) {
                    num += data[i][k] * x.data[k][j];
                }
                result.data[i][j] = num;
                num = 0;
            }
        }
        return result;
    }

    @Override
    public String toString() {
        StringBuffer sb = new StringBuffer();

        for (int i = 0; i < this.data.length; i++) {
            for (int j = 0; j < this.data[0].length; j++) {
                sb.append(data[i][j]);
                if (j != this.data[0].length - 1) sb.append(" ");
                else sb.append("\\n");
            }
        }
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        Matrix m = (Matrix) obj;
        if (this != obj) return false;
        if (obj == null || obj.getClass() != this.getClass()) return false;
        return this.rows == m.rows && this.cols == m.cols && Arrays.equals(data, m.data);
    }
}

MatrixTest类

package shiyan5;

public class MatrixTest {
    public static void main(String[] args) {
        System.out.println("------------分割线7------------");
        Matrix m1 = new Matrix(2, 3);
        System.out.println(m1);

        System.out.println("------------分割线8------------");
        double[][] data = {{1, 2, 3}, {7, 8, 9}};
        Matrix m2 = new Matrix(data);
        System.out.println(m2);

        System.out.println("------------分割线9------------");
        try {
            Matrix m3 = new Matrix(0, 3);
        } catch (IllegalIndexException i) {
            System.out.println("IllegalIndexException异常（行号<0，行号>=行数）");
        }

        System.out.println("------------分割线10------------");
        try {
            Matrix m4 = new Matrix(null);
        } catch (IllegalIndexException i) {
            System.out.println("IllegalIndexException异常（行号<0，行号>=行数）");
        }
        
        System.out.println("------------分割线11------------");
        System.out.println(m2.getCols());

        System.out.println("------------分割线12------------");
        System.out.println(m2.getRows());

        System.out.println("------------分割线13------------");
        System.out.println(m2.getData(0, 0));

        System.out.println("------------分割线14------------");
        m2.setData(0, 0, 10);
        System.out.println(m2.getData(0, 0));
        m2.setData(0, 0, 1);

        System.out.println("------------分割线15------------");
        try {
            System.out.println(m2.getData(-1, 0));
            System.out.println(m2.getData(m2.getRows(), 0));
        } catch (IllegalIndexException i) {
            System.out.println("IllegalIndexException异常（行号<0，行号>=行数）");
        }
        
        System.out.println("------------分割线16------------");
        try {
            m2.setData(0, -1, 0);
            m2.setData(0, m2.getCols(), 0);
        } catch (IllegalIndexException i) {
            System.out.println("IllegalIndexException异常（行号<0，行号>=行数）");
        }

        System.out.println("------------分割线17------------");
        double[][] data2 = {{1.0, 3.0}, {5.0, 7.0}, {7.0, 2.0}};
        Matrix m0 = new Matrix(data2);
        System.out.println(m2.multiply(m0));

        System.out.println("------------分割线18------------");
        try {
            Matrix num = m2.multiply(null);
        } catch (MatrixMultiplicationException e) {
            System.out.println("MatrixMultiplicationException异常");
        }

        System.out.println("------------分割线19------------");
        double[][] data3 = {{1.0, 3.0}, {5.0, 7.0}, {7.0, 2.0}, {7.0, 2.0}};
        Matrix m6 = new Matrix(data3);
        try {
            Matrix num = m2.multiply(m6);
        } catch (MatrixMultiplicationException e) {
            System.out.println("MatrixMultiplicationException异常");
        }

        System.out.println("------------分割线20------------");
        double[][] data4 = {{1, 2}, {3, 4}};//2列3行
        Matrix x4 = new Matrix(data4);
        System.out.println(x4.toString());
    }
}