Immutable——想破坏它也没办法

Immutable Pattern是指那些有着能够保证实例状态绝不会改变的类(immutable类)，在访问这样的实例中，可以省去使用共享机制所会浪费的时间。如果能妥善使用可以提高程序性能。

思考成对的mutable类与immutable类【执行性能】

 

setter还是有被用到，可能是在：1.getter方法里面判断，然后可能会改变值2.构造方法里面可能会改变值。

 

也许可以将这个类二分为mutable类和immutable类，再设计成可由mutable类的实例构造出immutable类的实例，并也可以从immutable类的实例构造出mutable类的实例。

public class StringBufferTest {
	public static void main(String[] args) {
		// String -- StringBuffer
		String s = "hello";           
		// StringBuffer sb = "hello"; //错误的，注意：不能把字符串的值直接赋值给StringBuffe
		// StringBuffer sb = s;       //错误的
		// 方式1:通过构造方法
		StringBuffer sb = new StringBuffer(s);
		System.out.println("sb:" + sb);    //sb:hello
		// 方式2：通过append()方法
		StringBuffer sb2 = new StringBuffer();
		sb2.append(s);
		System.out.println("sb2:" + sb2);  //sb2:hello
		//---------------------------------------------------
		// StringBuffer -- String
		StringBuffer buffer = new StringBuffer("java");
		// String(StringBuffer buffer)
		// 方式1:通过构造方法
		String str = new String(buffer);
		System.out.println("str:" + str);  //str:java
		// 方式2：通过toString()方法
		String str2 = buffer.toString();
		System.out.println("str2:" + str2);//str2:java
	}
}

　　要由多个字符串建立出新的字符串，用StringBuffer会比String快很多。

 

 

练习：

练习1：

 

解答：即使没有setter方法，可以不操作该对象改变对象的属性值，直接操作该属性的内存空间里的值，只要指针不变，对象的属性值就变了。

练习2：

 

 

 

 

解答：

 

练习3：

public final class MutablePerson {
    private String name;
    private String address;
    
    public MutablePerson(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public MutablePerson(ImutablePerson person) {
        this.name = person.getName();
        this.address = person.getAddress();
    }

    public synchronized void setPerson(String newName,String newAddress){
        name = newName;
        address = newAddress;
    }

    public synchronized ImutablePerson getImutablePerson(){
        return new ImutablePerson(this);
    }

    String getName() {
        return name;
    }

    String getAddress() {
        return address;
    }

    @Override
    public String toString() {
        return "MutablePerson{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

　　

package entity;

public final class ImutablePerson {
    private final String name;
    private final String address;

    public ImutablePerson(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public ImutablePerson(MutablePerson mutablePerson) {
        this.name = mutablePerson.getName();
        this.address=mutablePerson.getAddress();
    }

    public MutablePerson getMutablePerson(){
        return new MutablePerson(this);
    }

    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }

    @Override
    public String toString() {
        return "ImutablePerson{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

　　

测试逻辑：

MutablePerson mutable = new MutablePerson（“start”，“start"）;

给CrackerThread的MutablePerson赋值

run方法：（循环）{1.创建ImmutablePerson，参数为mutable2.如果immutable的name和address不对应就抛出异常

                                    }

创建三个CracherThread并启动

用无限循环调用mutable的setPerson方法。

 

相当于读写冲突吧。