1-1 采用Java语言声明复数类---》数据结构（Java版）（第4版）实验1：算法设计与分析

题目：

采用Java语言声明复数类，成员声明见1.1.3节复数抽象数据类型，增加实现有字符串构造复数、字符串描述、比较相等等操作。复数语法图如图1.7所示。

代码：

public class Test {

    // real：实部，imag：虚部
    private double real, imag;

    public Test(double real, double imag) {
        this.real = real;
        this.imag = imag;
    }

    public Test() {

    }

    /**
     * 字符串构造复数
     *
     * @param str 字符串
     * @return
     */
    public static Test getTest(String str) {

        Test test = null;

        // 判断是否有虚部
        if (str.contains("i")) {

            int index1 = str.indexOf("i");
            int index2 = str.indexOf("+");

            // 存储实部和虚部的值
            double real = 0;
            double imag = 0;

            // 判断虚部是否为1
            if (index1 == 0) {
                imag = 1;
            } else {
                // 判断虚部和实部的位置关系，确定虚部截取长度
                if (index1 < index2) {
                    // 使用trim()去除字符串前后空格
                    imag = Double.parseDouble(str.substring(0, index1).trim());
                } else {
                    imag = Double.parseDouble(str.substring(index2 + 1, index1).trim());
                }
            }

            // 判断实部是否为空
            if (index2 >= 0) {
                // 判断虚部和实部的位置关系，确定实部截取长度
                if (index1 < index2) {
                    // 使用trim()去除字符串前后空格
                    real = Double.parseDouble(str.substring(index2 + 1).trim());
                } else {
                    real = Double.parseDouble(str.substring(0, index2).trim());
                }
            } else {
                real = 0;
            }

            test = new Test(real, imag);

        } else {
            test = new Test(Double.parseDouble(str), 0);
        }

        return test;
    }

    /**
     * 字符串描述
     *
     * @param test 复数对象
     * @return
     */
    public static String getStr(Test test) {

        StringBuffer sb = new StringBuffer();

        // 判断实部是否是0
        if (test.real != 0.0) {
            sb.append(test.real);
        }

        // 判断虚部是否是0
        if (test.imag != 0.0) {
            if (test.real != 0.0) {
                sb.append("+");
            }
            if (test.imag != 1.0) {
                sb.append(test.imag);
            }
            sb.append("i");
        }

        // 若实部和虚部同时为0
        if (test.real == 0.0 && test.imag == 0.0) {
            sb.append("0");
        }

        return sb.toString();
    }

    /**
     * 判断两个复数对象是否相等
     *
     * @param test 被比较的复数对象
     * @return
     */
    public boolean equals(Test test) {

        boolean flag = false;

        // 判断复数对象的实部和虚部是否相等
        if (this.real == test.real && this.imag == test.imag) {
            flag = true;
        }

        return flag;
    }

    /**
     * 令两个复数对象相加
     *
     * @param test 被加和的复数对象
     * @return
     */
    public Test add(Test test) {

        return new Test(this.real + test.real, this.real + test.real);
    }

    /**
     * 令两个复数对象相减
     *
     * @param test 被减的复数对象
     * @return
     */
    public Test sub(Test test) {

        return new Test(this.real - test.real, this.real - test.real);
    }


    public static void main(String[] args) {

        // 测试
        String str = "1.2+2.1i";

        //  测试getTest方法，用于字符串构造复数
        Test test1 = Test.getTest(str);

        // 测试getStr()方法，用于字符串描述
        System.out.println(Test.getStr(test1));

        Test test2 = new Test(1.2, 2.1);

        // 测试equals()方法，用于比较相等
        System.out.println(test1.equals(test2) ? "两个复数对象相等" : "两个复数对象不相等");

        // 测试add()方法，用于复数加法
        System.out.println(Test.getStr(test1.add(test2)));

        // 测试sub()方法，用于复数减法
        System.out.println(Test.getStr(test1.sub(test2)));
    }

}

结果：

1.2+2.1i
两个复数对象相等
2.4+2.4i
0