实例探索Java模式之路——不变模式

不变模式

1、一个对象的状态在对象被创建之后就不再变化，这就是不变模式（缺少改变自身状态的行为），不变模式只涉及一个类，一个类的内部状态创建后，在整个生命周期都不会发生变化，这个类叫不变类，而不变模式就是使用这种类。


2、不变模式的两种形式：弱不变模式与强不变模式


弱不变模式：一个类的实例的状态是不可变的，但是这个类的子类的实例具有可能会变化的状态。


实现条件：
1、所考虑对象没有任何方法会修改对象状态。
2、所有的属性都应当是私有的，不声明任何的公开的属性。
3、这个对象所引用到的其他对象如果是可变对象的话，必须设法限制外界对这些可变对象的访问，以防止外界修改这些对象。


缺点：
1、一个弱不变的子对象可以可变对象；
2、这个可变的子对象可能可以修改父对象的状态，从而可能会允许外界修改父对象的状态。

强不变模式:一个类的实例的状态不会改变，子类的实例也具有不可变化的状态。


实现条件：一个类必须首先满足弱不变模式所要求的所有条件，并满足下面条件之一：
1、所考虑类所有的方法都应当是final;这样这个类的子类不能够置换调此类的方法。
2、这个类本身就是final的，那么这个类就不可能会有子类，从而不可能被子类修改。


3、String类是一个强不变类。
如果程序所处理的文字串有频繁的内容变化时，不宜用String,应当考虑StringBuffer类型。如果需要对文字串做大量的循环查询时，也不宜使用String类型，而应当考虑使用byte或char数组。


4、不变模式天生是线程友好的，核心思想是：

一个对象一旦被创建，则它的内部状态永远不会改变，所以没有一个线程可以修改其内部状态和数据，同时内部状态也绝不会自行发生改变，所以，对于不变对象的多线程操作不需要进行线程同步控制。

5、不变模式与只读属性区别：

比如一个对象的存活时间是只读的，以及人的年龄也是只读的，但是这是一个可变的属性，随着时间推移，这些属性会发生变化的。而不变模式则要求，无论出于什么原因，对象创建后，内部状态和数据保持绝对的稳定。

6、不变模式主要使用场景：

1、当对象创建后，内部状态和数据不再发生任何变化。
2、对象需要被共享，被多线程频繁访问（应用不变模式就是为了实现对象共享）。


7、不变模式实现：
1、去除setter方法以及所有修改自身属性的方法。
2、将所有属性设置为私有，并用final标记，确保其不可修改。
3、确保没有子类可以重载修改它的行为。
4、有一个可以创建完整对象的构造函数。


8、JDK中的不变模式:最典型的就是java.lang.String，所有的元数据包装类，都是使用不变模式实现的。


java.lang.String;
java.lang.Boolean;
java.lang.Byte;
java.lang.Character;
java.lang.Double;
java.lang.Float;
java.lang.Integer;
java.lang.Long;
java.lang.Short;

9、一个不变类：

//实现了一个不变的产品对象,不变类
public final class Product {// 确保无子类

private final String no;
private final String name;
private final double price;// final保证不会2此赋值


// 在创建对象时，必须指定数据，创建后无法修改
public Product(String no, String name, double price) {
super();
this.no = no;
this.name = name;
this.price = price;
}


public String getNo() {
return no;
}


public String getName() {
return name;
}


public double getPrice() {
return price;
}


}

不变类，复数类的例子：

public final class Complex extends Number implements java.io.Serializable, Cloneable,
Comparable {


// 虚数单位
static final public 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;
im = 0;
}


// 复数比较(作为参数)


public boolean equals(Complex z) {
return (re == z.re && im == z.im);
};


// 复数比较(作为对象)
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
} else if (obj instanceof Complex) {
return equals((Complex) obj);
} else {
return false;
}
}


@Override
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 double imag(Complex z) {
return z.im;
}


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


@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 static Complex multiply(Complex c1, Complex c2) {
// TODO Auto-generated method stub
return new Complex(c1.re * c2.re - c1.im * c2.im, c1.re * c2.im + c1.im
* c2.re);
}
}


// 这个类是final类，它的所有方法自动final，这个类是强不变类。

//客户端
public class client {


public static void main(String[] args) {


Complex c1 = new Complex(10, 20);
Complex c2 = new Complex(0, 1);


Complex resComplex = Complex.multiply(c1, c2);


System.out.println("实部=" + resComplex.real());
System.out.println("虚部=" + resComplex.imag());
}
}

通过此实例，相信对该模式有了进一步的认识。

每天努力一点，每天都在进步。