不变（Immutable）模式【行为模式第二篇】

不变（Immutable）模式
一个对象的状态在对象被创建之后就不再变化，这就是不变模式。

一、不变模式有两种模式
1、弱不变模式
一个类的实例的状态是不可变化的，但是这个类的子类的实例具有可能会变化的状态。这样的类符合弱不变模式的定义。
要实现弱不变模式，一个类必须满足下面条件：
第一、所考虑的对象没有任何方法会修改对象的状态，这样一来，当对象的构造子将对象的状态初始化之后，
      对象的状态便不再改变。
第二、所有的属性都应当是私有的。不要声明任何的公共的属性，以防客户端对象直接修改任何的内部状态。
第三、这个对象所引用到的其它对象如果是可变对象的话，必须设法限制外界对这些可变对象的访问，以防止外界修改
      这些对象。如果可能，应当尽量在不变对象内部初始化这些被引用到的对象，而不要在客户端初始化，然后再
      传入到不变对象内部来。如果某个可变对象必须在客户端初始化，然后再传入到不变对象里的话，就应当考虑
      在不变对象初始化的时候，将这个可变对象复制一份，而不再使用原来的拷贝。
弱不变模式的缺点是：
第一、一个弱不变对象的自对象可以是可变对象；换言之，一个弱不变对象的子对象可能是可变的
第二、这个可变的子对象可能可以修改父对象的状态，从而可能会允许外界修改父对象的状态。
2、强不变模式
一个类的实例的状态不会改变，同时它的子类的实例也具有不可变化的状态。这样的类符合强不变模式。
要实现强不变模式，一个类必须首先满足弱不变模式所要求的所有条件，并且还要满足下面的条件之一：
第一、所考虑的类所有的方法都应当是final：这样这个类的子类不能够置换掉此类的方法
第二、这个类本身就是final的，那么这个类就不可能会有子类，从而也就不可能有被子类修改的问题。593P

二、不变模式的优缺点
不变模式有很明显的有点：
1、因为不能修改一个不变对象的状态，所以可以避免由此引起的不必要的程序错误；换言之，一个不变模式的对象要比可变的
   对象更加容易维护。
2、因为没有任何一个线程能够修改不变对象的内部状态，一个不变对象自动就是线程安全的，
   这样就可以省掉处理同步化的开销。一个不变对象可以自由地被不同的客户端共享。
不变模式唯一的缺点是：
一旦需要修改一个不变对象的状态，就只好创建一个新的同类对象。在需要濒繁修改不变对象的环境里，会有大量的不变对象
作为中间结果被创建出来，再被java语言的垃圾回收器收集走。这是一种资源上的浪费。

三、一个用来说明不变模式的复数类例子

//-----
		package day1114;

@SuppressWarnings("serial")
public final class Complex extends Number implements java.io.Serializable,
		Cloneable, Comparable {
	// 虚数单位
	public static final Complex i = new Complex(0.0, 1.0);

	// 复数的实部
	private double re;

	// 复数的虚部
	private double im;

	// 构造子，根据传进的复数再构造一个数学值的复数
	public Complex(Complex z) {
		re = z.re;
		im = z.im;
	}

	// 根据传进的实部和虚部构造一个复数对象
	public Complex(double re, double im) {
		this.re = re;
		this.im = im;
	}

	// 构造子，根据一个实部构造复数对象
	public Complex(double re) {
		this.re = re;
		this.im = 0.0;
	}

	// 默认构造子，构造一个为零的复数
	public Complex() {
		re = 0.0;
		im = 0.0;
	}

	// 把本复数与作为参数传进的复数相比较
	public boolean equals(Complex z) {
		return (re == z.re && im == z.im);
	}

	// 把本对象与作为参数传进的对象相比较
	public boolean equals(Object obj) {
		if (obj == null) {
			return false;
		} else if (obj instanceof Complex) {
			return equals((Complex) obj);
		} else {
			return false;
		}
	}

	public int hashCode() {
		long re_bits = Double.doubleToLongBits(re);
		long im_bits = Double.doubleToLongBits(im);
		return (int) ((re_bits ^ im_bits) ^ ((re_bits ^ im_bits) >> 32));
	}

	// 返回本复数的实部
	public double real() {
		return re;
	}

	// 返回本复数的虚部
	public double imag() {
		return im;
	}

	// 静态方法，返还作为参数传进的复数的实部
	public static double real(Complex z) {
		return z.re;
	}

	// 静态方法，返还作为参数传进的复数的虚部
	public static double imag(Complex z) {
		return z.im;
	}

	// 静态方法，返还作为参数传进的复数的相反数
	public static Complex negate(Complex z) {
		return new Complex(-z.re, -z.im);
	}

	// 静态方法，返还作为参数传进的复数的共轭数
	public static Complex conjugate(Complex z) {
		return new Complex(z.re, -z.im);
	}

	// 静态方法，返还两个数的和
	public static Complex add(Complex x, Complex y) {
		return new Complex(x.re + y.re, x.im + y.im);
	}

	public static Complex add(Complex x, double y) {
		return new Complex(x.re + y, x.im);
	}

	public static Complex add(double x, Complex y) {
		return new Complex(x + y.re, y.im);
	}

	// 静态方法，返还两个数的差
	public static Complex subtract(Complex x, Complex y) {
		return new Complex(x.re - y.re, x.im - y.im);
	}

	public static Complex subtract(Complex x, double y) {
		return new Complex(x.re - y, x.im);
	}

	public static Complex subtract(double x, Complex y) {
		return new Complex(x - y.re, -y.im);
	}

	// 静态方法，返还两个数的乘积
	public static Complex multiply(Complex x, Complex y) {
		return new Complex(x.re * y.re - x.im * y.im, x.re * y.im + x.im * y.re);
	}

	public static Complex multiply(Complex x, double y) {
		return new Complex(x.re * y, x.im * y);
	}

	public static Complex multiply(double x, Complex y) {
		return new Complex(x * y.re, x * y.im);
	}

	public static Complex multiplyImag(Complex x, double y) {
		return new Complex(-x.im * y, x.re * y);
	}

	public static Complex multiplyImag(double x, Complex y) {
		return new Complex(-x * y.im, x * y.re);
	}

	// 静态方法，返还两个数的商
	public static Complex divide(Complex x, Complex y) {
		double a = x.re;
		double b = x.im;
		double c = y.re;
		double d = y.im;
		@SuppressWarnings("unused")
		double scale = Math.max(Math.abs(c), Math.abs(d));
		double den = c * c + d * d;
		return new Complex((a * c + b * d) / den, (b * c - a * d) / den);
	}

	public static Complex divide(Complex x, double y) {
		return new Complex(x.re / y, x.im / y);
	}

	public static Complex divide(double x, Complex y) {
		double den, t;
		Complex z;
		if (Math.abs(y.re) > Math.abs(y.im)) {
			t = y.im / y.re;
			den = y.re + y.im * t;
			z = new Complex(x / den, -x * t / den);
		} else {
			t = y.re / y.im;
			den = y.im + y.re * t;
			z = new Complex(x * t / den, -x / den);
		}
		return z;
	}

	// 静态方法，返还复数的绝对值
	public static double abs(Complex z) {
		return z.re * z.re - z.im * z.im;
	}

	// 静态方法，返还复数的相位角
	public static double argument(Complex z) {
		return Math.atan2(z.im, z.re);
	}

	// 返还复数的字符串
	public String toString() {
		if (im == 0.0) {
			return String.valueOf(re);
		}
		if (re == 0.0) {
			return String.valueOf(im) + "i";
		}

		String sign = ((im < 0.0) ? "" : "+");
		return (String.valueOf(re) + sign + String.valueOf(im) + "i");
	}

	@Override
	public double doubleValue() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public float floatValue() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public int intValue() {
		// TODO Auto-generated method stub
		return 0;
	}

	@Override
	public long longValue() {
		// TODO Auto-generated method stub
		return 0;
	}

	public int compareTo(Object o) {
		// TODO Auto-generated method stub
		return 0;
	}
}
		
		//客户端
		public class TestComplex{
			public static void main(String args[]){
				Complex c1 = new Complex(10,20);
				Complex c2 = new Complex(0,1);
				Complex res = Complex.mnltiply(c1,c2);
				System.out.println("Real part = " + res.real());
				System.out.println("Imaginary part = " + res.imag());
			}
		}