实现复数的加减乘除（构造函数的妙用）

在复数类中，加减乘除各用两种方法实现。举个例子，就比如a = b + c和a += b;

在该复数类中，用到了static修饰符，如此，被修饰的方法可以用类名通过圆点运算符直接调用。可以解决没有对象调用的问题。用类名直接调用，传入两个参数。

减法利用加法实现，除法利用乘法实现。

在除法中，如果除数为0，则会抛出异常。

编写了四种构造方法：无参，单参，双参以及直接传入一个复数。使用this（）的方法调用双参构造函数完成无参和单参构造。

并实现了getter和setter方法，以便取得和注入初值。

重载了toString方法，自定义输出形式。

可以实现复数的加减乘除。因为有a += b这类方法，使得不光可以实现两个复数的运算，还可以实现连加，连乘等操作。

具体代码如下：

/*
 * @auther-yc
 * 2018/9/23
 */
package com.mec.complex;

public class Complex {
	//定义两个全局变量，分别表示复数的实部和虚部；
	private double row;
	private double col;
	
	//无参构造
	public Complex() {
		//使用this()方法调用双参构造，使得默认初始值为0.0 + 0.0i;
		this(0.0, 0.0);
	}

	public Complex(double row) {
		this(row, 0.0);
	}
	
	public Complex(Complex complex) {
		this(complex.row, complex.col);
	}
	
	public Complex(double row, double col) {
		this.setRow(row);
		this.setCol(col);
	}
	
	//实现一系列的getter和setter方法；
	public double getRow() {
		return row;
	}

	public void setRow(double row) {
		this.row = row;
	}

	public double getCol() {
		return col;
	}

	public void setCol(double col) {
		this.col = col;
	}

	//该方法可取得一个复数的相反数，这样就可以利用加法来实现减法运算。
	public static Complex opposite(Complex complex) {
		complex.row = - complex.row;
		complex.col = - complex.col;
		
		return complex;
	}
	
	//该方法可取的一个复数的倒数，这样就可以利用乘法来实现除法运算。
	public static Complex reciprocal(Complex complex) {
		double row = (complex.row) / (complex.row * complex.row + complex.col * complex.col);
		double col = (-complex.col) / (complex.row * complex.row + complex.col * complex.col);
		
		return new Complex(row, col);
	}
	
	//a = b + c;将该方法定义为静态，可以使用类名直接调用，然后输出结果。不用新定义一个复数去接收其和值；
	//且该方法实质上是用其中一个参数调用单参的加法实现。
	public static Complex add(Complex one, Complex another) {
		return new Complex(one).add(another);
	}
	
	//a += b;
	public Complex add(Complex one) {
		this.row += one.row;
		this.col += one.col;
		
		return this;
	}
	
	//a = b - c;
	public static Complex sub(Complex one, Complex another) {
		return new Complex(one).add(opposite(another));
	}
	
	public Complex sub(Complex complex) {
		return this.add(opposite(complex));
	}
	
	//a = b * c;
	public static Complex mul(Complex one, Complex another) {
		return new Complex(one).mul(another); 
	}
	
	//a *= b;
	public Complex mul(Complex complex) {
		double row = this.row;
		this.row = this.row * complex.row - this.col * complex.col;
		this.col = row * complex.col + this.col * complex.row;
		
		return this;
	}
	
	//a /= b;此处抛出自定义的异常“除零错”，当传入的参数作为除数运算是就会报异常！
	public Complex div(Complex complex) throws DivideZeroException {	
		if((Math.abs(complex.row) < 1e-6) && (Math.abs(complex.col) < 1e-6)) {
			throw new DivideZeroException("除零错");
		}
		return new Complex(this.mul(reciprocal(complex)));
	}
	
	//a = b / c;
	public static Complex div(Complex one, Complex another) throws DivideZeroException {
		if((Math.abs(another.row) < 1e-6) && (Math.abs(another.col) < 1e-6)) {
			throw new DivideZeroException("除零错");
		}
		return new Complex(one).mul(reciprocal(another));
	}
	
	//重载toString方法，可以按自定义的格式输出；
	@Override
	public String toString() {
		return "(" + row + ", " + col + ")";
	}
	
}



/*
 * 异常类
 * @auther-yc
 * 2018/9/23
 */
package com.mec.complex;

public class DivideZeroException extends Exception {
	private static final long serialVersionUID = -917710262683840175L;

	public DivideZeroException() {
	}

	public DivideZeroException(String arg0, Throwable arg1, boolean arg2, boolean arg3) {
		super(arg0, arg1, arg2, arg3);
	}

	public DivideZeroException(String arg0, Throwable arg1) {
		super(arg0, arg1);
	}

	public DivideZeroException(String arg0) {
		super(arg0);
	}

	public DivideZeroException(Throwable arg0) {
		super(arg0);
	}
	
}