多线程程序设计学习（3）immutable pattern模式

Immutable pattern【坚不可摧模式】

一:immutable pattern的参与者
--->immutable(不变的)参与者
        1.1:immutable参与者是一个字段的值都无法更改的类。
        1.2:immutable也没有任何用来更改字段值的方法。
        1.3:immutable参与者方法不需要设置synchronized

二：immutable pattern模式什么时候使用
--->当实例产生后，状态不再变化时
        2.1实例状态不再变化是首要条件。
        2.2何为不可变状态。就是实例的值不会发生变化。
--->实例需要共享，而且访问频繁时
--->String 类是immutable类不需要synchronized保护
       StringBuffer类是非immutable类需要synchronized保护


三：immutable pattern思考
--->final关键字
        2.1:final类：当生命final类，该类无法延伸，就是不能定义子类。
        2.2:final方法：
                        若实例方法(非静态)声明成final时，该方法无法被子类覆盖重写。
                        若将类方法(静态)声明成final时，该方法无法被子类所隐藏
        2.3final变量
                        final字段只能赋值一次。
                        final（非静态）字段赋值分两种方法：(1)声明时赋值(2)通过构造器赋值
                        final（静态）字段赋值分两种方法:(1)声明时赋值（2）通过静态块赋值
        2.3覆盖和隐藏的概念
                        实例方法被子类方法所覆盖时，实际被调用的方法是在执行时决定的
                        类方法被子类方法隐藏时，实例被调用的方法是在编译时决定的。

--->immutable不变性很微妙。不是设置finnal,私有化，不提供赋值方法，就是永久不变性的。
                        final只是不可再次赋值。如果final的字段是一个可变的引用属性，那么immutable，就会被破坏。

room类

package com.yeepay.sxf.thread2;
/**
 * 看似是immutable类
 * 其实不是。
 * Student是可变的类
 * @author sxf
 *
 */
public final class Room {

    private final Student student;
    private final String name;

    public Room(String name,Student student) {
        super();
        this.student=student;
        this.name = name;
    }

    public Student getStudent() {
        student.setName("sxf");
        return student;
    }

    public String getName() {
        return name;
    }
    
}

student类

package com.yeepay.sxf.thread2;

public class Student {
    private String name;
    private String address;
    public Student() {
        super();
    }
    public Student(String name, String address) {
        super();
        this.name = name;
        this.address = address;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
    
    
}

测试类

package com.yeepay.sxf.thread2;
/**
 * 测试线程
 * @author sxf
 *
 */
public class Test {

    public static void main(String[] args) {
        
        
        
        Student student=new Student("hsl", "hnlh");
        Room room=new Room("ddd", student);
        Student student2=room.getStudent();
        System.out.println(student2.getName());
        
        //打印 ：sxf
    }
}

immutable范例（immutable只是一个概念模式，而不是一个固定的格式）

package com.yeepay.sxf.thread2;
/**
 * 坚不可摧模式。
 * @author sxf
 * 
 * 一个类定义成final类，是不允许有子类
 * 一个变量定义成final变量，意味着，一旦第一次赋值，便不可更改。
 * 其中的字段也是不可变的
 * 
 * 
 * 这个不可变性。不一定由final来决定。
 * 所谓不可变性，是一种设计的模式。不可改变，是为了防止多线程破坏对象。
 * 这种不可变，不需要保护的前提，就是不能被修改，一旦实例化，只提供读取操作
 * 而是可以通过很多方式：比如，私有化，不提供赋值操作，final修饰。
 *
 */
public final class Persion {
    //声明变量
    private final String name;
    private final String address;
    
    //构造器赋值
    public Persion(String name, String address) {
        this.name = name;
        this.address = address;
    }

    //提供get访问方法，但不提供set赋值方法
    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }
    
    
    
    
    
    
}