一、 final修饰变量
- final修改基本数据类型,则基本数据类型的值不能修改
- final修改引用类型变量,则该引用不能修改,但是该变量可以修改。
public class Test4 {
public static void main(String[] args) {
final int a = 10;
// a = 20; 编译错误
final Test t = new Test("d",5);
// t44 = new Test(); 编译错误
System.out.println("修改前name:"+t.getName());
//可以修改对象的内部成员的值
t.setName("c");
System.out.println("修改后name:"+t.getName());
}
}
public class Test {
private String name;
private int age;
public Test() {
}
public Test(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
修改前name:d
修改后name:c
二、不可变对象
我们经常听到这样一句话“String 对象不可以修改”,这到底是什么意思呢?
先来看下不可变对象的定义:
不可变对象是指一个对象的状态在对象被创建之后就不再变化。不可变对象对于缓存是非常好的选择,因为你不需要担心它的值会被更改。
创建一个不可变类:
- 将类声明为final,所以它不能被继承;
- 将所有的成员声明为私有的,这样就不允许直接访问这些成员;
- 对变量不要提供setter方法;
- 将所有可变的成员声明为final,这样只能对它们赋值一次;
- 通过构造器初始化所有成员,进行深拷贝(deep copy);
- 在getter方法中,不要直接返回对象本身,而是克隆对象,并返回对象的拷贝;
如果构造器传入的对象直接赋值给成员变量,还是可以通过对传入对象的修改进而导致改变内部变量的值。例如:
public final class ImmutableDemo {
private final int[] myArray;
public ImmutableDemo(int[] array) {
this.myArray = array; // wrong
}
}
这种方式不能保证不可变性,myArray和array指向同一块内存地址,用户可以在ImmutableDemo之外通过修改array对象的值来改变myArray内部的值。
为了保证内部的值不被修改,可以采用深度copy来创建一个新内存保存传入的值。正确做法:
public final class MyImmutableDemo {
private final int[] myArray;
public MyImmutableDemo(int[] array) {
this.myArray = array.clone();
}
}
三、String对象的不可性
看下String部分源代码
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence
{
/** The value is used for character storage. */
private final char value[];
/** The offset is the first index of the storage that is used. */
private final int offset;
/** The count is the number of characters in the String. */
private final int count;
/** Cache the hash code for the string */
private int hash; // Default to 0
....
public String(char value[]) {
this.value = Arrays.copyOf(value, value.length); // deep copy操作
}
...
public char[] toCharArray() {
// Cannot use Arrays.copyOf because of class initialization order issues
char result[] = new char[value.length];
System.arraycopy(value, 0, result, 0, value.length);
return result;
}
...
}
如上代码所示,可以观察到以下设计细节:
- String类被final修饰,不可继承
- string内部所有成员都设置为私有变量
- 不存在value的setter
- 并将value和offset设置为final。
- 当传入可变数组value[]时,进行copy而不是直接将value[]复制给内部变量.
- 获取value时不是直接返回对象引用,而是返回对象的copy.
这都符合上面总结的不变类型的特性,也保证了String类型是不可变的类。
四、String对象是否正的不可变
其实可以通过反射机制,改变其值。
public class Test {
public static void main(String[] args) throws Exception {
String s="0123456789";
System.out.println("改变前:s=" + s);
Field f = s.getClass().getDeclaredField("value");
f.setAccessible(true);
f.set(s, new char[]{'a', 'b', 'c'});
System.out.println("改变后:s=" + s);
}
}
参考文章:
http://www.cnblogs.com/jaylon/p/5721571.html
http://www.cnblogs.com/wcyBlog/p/4073725.html
http://blog.csdn.net/z69183787/article/details/44085031