package book.oo;

public class ComplexNumber implements Cloneable{

	/** 復數的實部 */
	private double realPart;

	/** 復數的虛部 */
	private double imaginaryPart;

	/** 默認構造函數 */
	public ComplexNumber() {
		this.realPart = 0.0;
		this.imaginaryPart = 0.0;
	}

	/**
	 * 構造函數
	 * @param a 實部
	 * @param b 虛部
	 */
	public ComplexNumber(double a, double b) {
		this.realPart = a;
		this.imaginaryPart = b;
	}

	/**
	 * 復數的加法運算。 
	 * c = a + b的運算法則是： 
	 * c.實部 = a.實部 + b.實部; c.虛部 = a.虛部 + b.虛部
	 * @param aComNum  加數
	 * @return
	 */
	public ComplexNumber add(ComplexNumber aComNum) {
		if (aComNum == null) {
			System.err.println("對象不能夠為null！");
			return new ComplexNumber();
		}
		return new ComplexNumber(this.realPart + aComNum.getRealPart(),
				this.imaginaryPart + aComNum.getImaginaryPart());
	}

	/**
	 * 復數的減法運算。 
	 * c = a - b的運算法則是： 
	 * c.實部 = a.實部 - b.實部; c.虛部 = a.虛部 - b.虛部
	 * @param aComNum  減數
	 * @return
	 */
	public ComplexNumber decrease(ComplexNumber aComNum) {
		if (aComNum == null) {
			System.err.println("對象不能夠為null！");
			return new ComplexNumber();
		}
		return new ComplexNumber(this.realPart - aComNum.getRealPart(),
				this.imaginaryPart - aComNum.getImaginaryPart());
	}

	/**
	 * 復數的乘法運算。 
	 * c = a * b的運算法則是： 
	 * c.實部 = a.實部 * b.實部 - a.虛部 * b.虛部; 
	 * c.虛部 = a.虛部 * b.實部 + a.實部 * b.虛部;
	 * @param aComNum  乘數
	 * @return
	 */
	public ComplexNumber multiply(ComplexNumber aComNum) {
		if (aComNum == null) {
			System.err.println("對象不能夠為null！");
			return new ComplexNumber();
		}
		double newReal = this.realPart * aComNum.realPart - this.imaginaryPart
				* aComNum.imaginaryPart;
		double newImaginary = this.realPart * aComNum.imaginaryPart
				+ this.imaginaryPart * aComNum.realPart;
		ComplexNumber result = new ComplexNumber(newReal, newImaginary);
		return result;
	}

	/**
	 * 復數的除法運算。 
	 * c = a / b 的運算法則是： 
	 * c.實部 = (a.實部 * b.實部 + a.虛部 * b.虛部) / (b.實部 *b.實部 + b.虛部 * b.虛部); 
	 * c.虛部 = (a.虛部 * b.實部 - a.實部 * b.虛部) / (b.實部 * b.實部 + b.虛部 * b.虛部);
	 * @param aComNum  除數
	 * @return
	 */
	public ComplexNumber divide(ComplexNumber aComNum) {
		if (aComNum == null) {
			System.err.println("對象不能夠為null！");
			return new ComplexNumber();
		}
		if ((aComNum.getRealPart() == 0) && (aComNum.getImaginaryPart() == 0)) {
			System.err.println("除數不能夠為0！");
			return new ComplexNumber();
		}

		double temp = aComNum.getRealPart() * aComNum.getRealPart()
				+ aComNum.getImaginaryPart() * aComNum.getImaginaryPart();
		double crealpart = (this.realPart * aComNum.getRealPart() + this.imaginaryPart
				* aComNum.getImaginaryPart())
				/ temp;
		double cimaginaryPart = (this.imaginaryPart * aComNum.getRealPart() - this.realPart
				* aComNum.getImaginaryPart())
				/ temp;
		return new ComplexNumber(crealpart, cimaginaryPart);
	}

	/**
	 * 將一個復數顯示為字符串
	 */
	public String toString() {
		return this.realPart + " + " + this.imaginaryPart + "i";
	}

	/**
	 * 比較一個對象是否和這個復數對象的值相等
	 */
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		}
		// 首先判斷a是不是一個復數對象，instanceof關鍵字是用來判斷對象的類型。
		if (obj instanceof ComplexNumber) {
			// 如果a是復數對象，需要將它強制類型轉換成復數對象，才能調用復數類提供的方法。
			ComplexNumber b = (ComplexNumber) obj;
			if ((this.realPart == b.getRealPart())
					&& (this.imaginaryPart == b.getImaginaryPart())) {
				return true;
			} else {
				return false;
			}
		} else {
			return false;
		}
	}

	/**
	 * 獲得該復數對象的hashcode
	 */
	public int hashCode() {
		// 如果兩個復數對象是equals的，那么它們的hashCode也必須相同。
		// 兩個值相等的復數對象通過toString()方法得到的輸出字符串是一樣的，
		// 于是，可以把得到的字符串的hashCode當作復數對象的hashCode
		return this.toString().hashCode();
	}

	/**
	 * 根據現有對象克隆一個新對象
	 */
	public Object clone() {
		// 如果你要使自定義的類能夠被clone,就必須實現Cloneable接口并且重寫它的clone()方法．
		// 如果你僅僅重寫了clone方法而沒有在類的聲明中添加實現Cloneable接口，調用clone方法時將會出現
		// CloneNotSupportedException異常，讀者可以試試。
		try {
			ComplexNumber newObject = (ComplexNumber) super.clone();
			newObject.setRealPart(this.realPart);
			newObject.setImaginaryPart(this.imaginaryPart);
			return newObject;
		} catch (CloneNotSupportedException e) {
			// //如果沒有實現Cloneable接口，拋出異常
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * @return 返回 imaginaryPart。
	 */
	public double getImaginaryPart() {
		return imaginaryPart;
	}

	/**
	 * @param imaginaryPart  要設置的 imaginaryPart。
	 */
	public void setImaginaryPart(double imaginaryPart) {
		this.imaginaryPart = imaginaryPart;
	}

	/**
	 * @return 返回 realPart。
	 */
	public double getRealPart() {
		return realPart;
	}

	/**
	 * @param realPart  要設置的 realPart。
	 */
	public void setRealPart(double realPart) {
		this.realPart = realPart;
	}

	public static void main(String[] args) throws CloneNotSupportedException {
		ComplexNumber a = new ComplexNumber(2, 4);
		ComplexNumber b = new ComplexNumber(2, 4);
		System.out.println("ComplexNumber a: " + a.toString());
		System.out.println("ComplexNumber b: " + b.toString());

		System.out.println("a.euqals(b) = " + a.equals(b));
		System.out.println("a.hashCode = " + a.hashCode() 
				+ "; b.hashCode = " + b.hashCode());
		System.out.println("a.clone = " + a.clone().toString());

//		System.out.println("(a + b) = " + a.add(b).toString());
//		System.out.println("(a - b) = " + a.decrease(b).toString());
//		System.out.println("(a * b) = " + a.multiply(b).toString());
//		System.out.println("(a / b) = " + a.divide(b).toString());
		
		
//		System.out.println(a.equals(b));
//		ComplexNumber c = new ComplexNumber(1, 2);
//		ComplexNumber d = new ComplexNumber(1.00, 2.0);
//
//		ComplexNumber e = (ComplexNumber) d.clone();
//		System.out.println(e.toString());

	}
}