Java复数Complex类

发表于2021-03-15更新于2021-05-08字数统计2.7k阅读时长22分

=====taoyyz小陶©版权所有=====

实验二 定义一个复数类，并实现以下复数类的方法

要求：

  定义一个复数类，并实现以下复数类的方法：构造方法、得到实部、得到虚部。
1、复数类 Complex 必须满足如下要求：
(1) 复数类 Complex 的属性有：
realPart : double 型 ，私有属性，代表复数的实数部分
imaginPart : double 型 ，私有属性，代表复数的虚数部分11

(2) 复数类 Complex 的构造方法有：
Complex( ) : 构造函数，将复数的实部和虚部都置 0。
Complex( double r , double i ) : 构造函数，形参 r 为实部的初值，i 为虚部的初值。

(3) 复数类 Complex 的公有方法有：
void setReal(): 设置复数对象的实部值；
void setImagin (): 设置复数对象的虚部值；
double getReal(): 获得复数对象的实部数值；
double getImagin (): 获得复数对象的虚部数值；

Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。
说明：（a+bi）+(c+di)= (a+c)+(b+d)i

Complex complexSub(Complex a) : 将当前复数对象与形参复数对象相减，所得的结果仍是一个复数值，返回给此方法的调用者。

Complex complexMulti(Complex a) : 将当前复数对象与形参复数对象相乘，所得的结果仍是一个复数值，返回给此方法的调用者。
说明：（a+bi）(c+di)=ac+bci+adi+bdi2=(ac-bd)+(bc+ad)i

Complex complexDiv(Complex a) : 将当前复数对象与形参复数对象相除，所得的结果仍是一个复数值，返回给此方法的调用者。
说明：复数相除其实采用的是分子分母同时乘以分母的共轭复数，用以将分母的虚部消除掉，除法可调用乘法进行计算更简便。

boolean equals(Complex a) : 将当前复数对象与形参复数对象进行比较，判断是否相等，返回一个布尔值。

String toString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中 a 和 b 分别为实部和虚部的数据，注意特殊数值的情况，如实部为 0、虚部为负，等等情况的表现方法。

常见复数的写法有：3+2i，3-2i，4+i，4-i，1，0，-2i，i，-i 等(应当编写一个数组，存入以上9个复数，然后循环一次性全部输出，便于检查)。

2、定义个 ComplexDemo 类：
该类是程序的入口，要求能在主方法中创建至少 3 个复数（两个做操作数，通过键盘输入实部和虚部创建，一个做结果，不需实部和虚部），然后调用上述方法进行运算，并打印相应结果进行观察。

思路：

两个类：Complex和ComplexDemo
其中：1.在Complex类中定义复数的实部和虚部，double型。
     2.定义Getter/Setter方法
     3.定义复数的加减乘除方法，返回值是Complex类，返回给此方法的调用者。
     //对于3.也就是说谁调用的 加减乘除，结果返回给这个调用者，改变其值
     4.定义equals()方法和toString()方法
     //对于equals()方法，比较两个Complex类的实部和虚部是否相同
     //对于toString()方法，遇到特殊情况(例如实部/虚部)为0，简化输出
     //对于toString()方法，当虚部为1/-1时，简化掉1，保留i以及符号
     5.在主方法中创建3个复数，其中2个通过键盘输入实部和虚部，进行运算
     6.toString()方法的检验可以通过存入多种极端情况测试简化效果

代码：

Complex类：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
package com.experiment.exp2;

import java.text.DecimalFormat;
import java.util.Scanner;

/**
 * @Author taoyyz(陶俊杰)
 * @Date 2021/3/3 1:07
 * @Version 1.0
 */
public class Complex {
    private double realPart;
    private double imaginPart;

    public Complex() {
    }

    public Complex(double r, double i) {
        this.realPart = r;
        this.imaginPart = i;
    }

/*    public Complex(String string) {       //随意以字符串输入复数，例如3+4i，但是实现起来太复杂了暂时没时间写了
        boolean isRealPart=true;
        char[] chars = string.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if (chars[i]=='+'||chars[i]=='-'){
                continue;
            } else {
                if (isRealPart) {
                    this.realPart=chars[i];
                }
            }
        }
    }*/

    public double getReal() {
        return realPart;
    }

    public void setReal(double realPart) {
        this.realPart = realPart;
    }

    public double getImagin() {
        return imaginPart;
    }

    public void setImagin(double imaginPart) {
        this.imaginPart = imaginPart;
    }

    public Complex complexAdd(Complex a) {      //复数的加法
        this.realPart += a.realPart;
        this.imaginPart += a.imaginPart;
        return this;
    }

    public Complex complexSub(Complex a) {      //复数的减法
        this.realPart -= a.realPart;
        this.imaginPart -= a.imaginPart;
        return this;
    }

    public Complex complexMulti(Complex a) {    //复数的乘法
        double r, i;
        r = (this.realPart * a.realPart - this.imaginPart * a.imaginPart);
        i = (this.imaginPart * a.realPart + this.realPart * a.imaginPart);
        return new Complex(r, i);
    }

    public Complex complexDiv(Complex a) {  //复数的除法
        //注意除数的实部和虚部不能同时为0，否则会导致除法运算时分母为0出错
        while (a.realPart == 0 && a.imaginPart == 0) {
            System.out.println("除数的实部和虚部不能同时为0，请重新输入");
            System.out.println("重新输入除数的实部：");
            a.realPart = new Scanner(System.in).nextDouble();
            System.out.println("重新输入除数的虚部：");
            a.imaginPart = new Scanner(System.in).nextDouble();
        }
        double r, i;
        r = (this.realPart * a.realPart + this.imaginPart * a.imaginPart) /
                (Math.pow(a.realPart, 2) + Math.pow(a.imaginPart, 2));
        i = (this.imaginPart * a.realPart - this.realPart * a.imaginPart) /
                (Math.pow(a.realPart, 2) + Math.pow(a.imaginPart, 2));
        return new Complex(r, i);
    }

    public Complex ConjugateComNum() { //返回共轭复数
        this.imaginPart *= -1;
        return this;
    }

    public boolean equals(Complex a) {
        if (this == a) return true;
        if (a == null || getClass() != a.getClass()) return false;
        return this.realPart == a.realPart && this.imaginPart == a.imaginPart;
    }

    @Override
    public String toString() {
        DecimalFormat df = new DecimalFormat("#.##");
        String rp = df.format(this.realPart);
        String ip = df.format(this.imaginPart);
        String result = "";
        if (this.realPart != 0) {
            if (this.imaginPart == 0)
                result = rp;
            else if (this.imaginPart == 1)
                result = rp + "+i";
            else if (this.imaginPart == -1)
                result = rp + "-i";
            else if (this.imaginPart > 0)
                result = rp + "+" + ip + "i";
            else
                result = rp + ip + "i";
        } else {
            if (this.imaginPart == 0)
                result = "0";
            else if (this.imaginPart == 1)
                result = "i";
            else if (this.imaginPart == -1)
                result = "-i";
            else
                result = ip + "i";
        }
        return result;
    }

    /*@Override
    public String toString() {
        //保留两位小数
        DecimalFormat df = new DecimalFormat("#.##");
        String formatRealPart = df.format(this.realPart);
        String formatImaginPart = df.format(this.imaginPart);
        //处理虚部符号 正负
        String symbol;
        if (imaginPart >= 0) {
            symbol = "+";
        } else {
            symbol = "";
        }
        //实部为0
        if (realPart == 0) {
            //虚部也为0
            if (imaginPart == 0) {
                return "0";
            }
            //实部为0，虚部不为0且为整数
            if (imaginPart % 1 == 0) {
                if (imaginPart == 1) {
                    return "i";
                }
                if (imaginPart == -1) {
                    return "-i";
                }
                return symbol + (int) imaginPart + "i";
            }
            //虚部不为整数时
            return symbol + formatImaginPart + "i";
        }
        //否则实部不为0
        //虚部为0，实部不为0
        if (imaginPart == 0) {
            //实部为整数
            if (realPart % 1 == 0) {
                return String.valueOf((int) realPart);
            }
            //实部不为整数
            return formatRealPart;
        }

        //实部和虚部都不为0
        //实部为整数
        if (realPart % 1 == 0) {
            //虚部也为整数
            if (imaginPart % 1 == 0) {                                      //实部和虚部都为整数
                if (imaginPart == 1) {
                    return (int) realPart + symbol + "i";                   //虚部为1
                }
                if (imaginPart == -1) {                                     //虚部为-1
                    return (int) realPart + "-i";
                }
                return (int) realPart + symbol + (int) imaginPart + "i";    //实部和虚部都为整数
            } else {
                return (int) realPart + symbol + formatImaginPart + "i";    //实部为整数，虚部不为整数
            }
            //实部不为整数
        } else if (imaginPart % 1 == 0) {
            return formatRealPart + symbol + (int) imaginPart + "i";         //只有虚部为整数
        } else {
            return formatRealPart + symbol + formatImaginPart + "i";         //实部和虚部都不为整数
        }
    }*/
}

ComplexDemo类(含main方法)：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
package com.experiment.exp2;

/*
    定义个 ComplexDemo 类：
    该类是程序的入口，要求能在主方法中创建至少 3 个复数
    （两个做操作数，通过键盘输入实部和虚部创建，一个做结果，不需实部和虚部）
    ，然后调用上述方法进行运算，并打印相应结果进行观察。
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @Author taoyyz(陶俊杰)
 * @Date 2021/3/3 1:16
 * @Version 1.0
 */
public class ComplexDemo {
    public static void main(String[] args) {
        Complex result = new Complex(); //创建一个复数对象 作为结果 不需要实部和虚部
        printComplexArray();
        while (true) {
            System.out.println("  1. add()");
            System.out.println("  2. sub()");
            System.out.println("  3. multi()");
            System.out.println("  4. div()");
            System.out.println("  5. 退出程序");
            System.out.print("选择操作：");
            int i = new Scanner(System.in).nextInt();
            switch (i) {
                case 1:
                    add();
                    break;
                case 2:
                    sub();
                    break;
                case 3:
                    multi();
                    break;
                case 4:
                    div();
                    break;
                case 5:
                    return;
            }
            System.out.println("===================");
        }

//        add();
//        sub();
//        multi();
//        div();
    }

    public static ArrayList<Complex> input() {
        //创建集合方便存放多个复数对象
        ArrayList<Complex> arrayList = new ArrayList<>();
        //通过键盘输入两个复数
        for (int i = 0; i < 2; i++) {
            arrayList.add(inputComplex(i + 1));
        }
        return arrayList;
    }

    public static void add() {
        ArrayList<Complex> arrayList = input();
        //加法运算  仅适用于2个复数相加
        System.out.println(arrayList.get(0) + " + " + arrayList.get(1) + " = "
                + arrayList.get(0).complexAdd(arrayList.get(1)));
    }

    public static void sub() {
        ArrayList<Complex> arrayList = input();
        //减法运算  仅适用于2个复数相减
        System.out.println(arrayList.get(0) + " - " + arrayList.get(1) + " = "
                + arrayList.get(0).complexSub(arrayList.get(1)));
    }

    public static void multi() {
        ArrayList<Complex> arrayList = input();
        //乘法运算  仅适用于2个复数相乘
        System.out.println(arrayList.get(0) + " * " + arrayList.get(1) + " = "
                + arrayList.get(0).complexMulti(arrayList.get(1)));
    }

    public static void div() {
        ArrayList<Complex> arrayList = input();
        //除法运算  仅适用于2个复数相除
        System.out.println(arrayList.get(0) + " ÷ " + arrayList.get(1) + " = "
                + arrayList.get(0).complexDiv(arrayList.get(1)));
    }

    public static Complex inputComplex(int seq) {
        //输入复数的实部和虚部，产生一个复数并返回
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入第" + seq + "个复数的实部：");
        double realPart = scanner.nextDouble();
        System.out.print("请输入第" + seq + "个复数的虚部：");
        double imaginPart = scanner.nextDouble();
        System.out.println("----------");
        return new Complex(realPart, imaginPart);
    }

    public static void printComplexArray() {
        //存入9个复数对象 方便检查
        ArrayList<Complex> complexes = new ArrayList<>(Arrays.asList(new Complex(3, 2), new Complex(3, -2),
                new Complex(4, 1), new Complex(4, -1), new Complex(1, 0), new Complex(0, 0),
                new Complex(0, -2), new Complex(0, 1), new Complex(0, -1)));
        for (Complex complex : complexes) {
            System.out.print(complex + "  ");
        }
        System.out.println();
    }
}

运行截图：

Complex01 Complex02 Complex03

心得：

  手动实现一个Complex类，想要做到严谨无Bug还是有一定的难度。对于强迫症患者来说，toString()方法就有够麻烦的了，而加减乘除方法可以通过百度查资料获得算术方法。
  注意在乘除法处理时，上一条语句改变了realPart的值，在下一句又用到realPart值时会造成计算错误，所以这个时候需要一个中间变量来避免这种情况。
  一般情况下对复数对象本身进行运算，并且返回给调用者时，可以直接return this;
  CardID身份证类即将于下一期上线💗