Java中的不可变类

最新推荐文章于 2022-05-23 08:15:00 发布

z923966545

最新推荐文章于 2022-05-23 08:15:00 发布

阅读量927

点赞数

分类专栏： JAVA 文章标签： java 不可变类 final 缓存

JAVA 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

概念：不可变类的意思是创建该类的实例后，该实例的属性是不可改变的。java中的8个包装类和String类都是不可变类。所以不可变类并不是指该类是被final修饰的，而是指该类的属性是被final修饰的。

自定义不可变类遵守如下原则：

1、使用private和final修饰符来修饰该类的属性。

2、提供带参数的构造器，用于根据传入的参数来初始化属性。

3、仅为该类属性提供getter方法，不要提供setter方法。

4、如果有必要，重写hashCode和equals方法，同时应保证两个用equals方法判断为相等的对象，其hashCode也应相等。

构造一个不可变类非常容易，下面举一个简单例子：

[java] view plain copy

package com.home;
public class Address {
private final String detail;
public Address() {
this.detail = "";
}
public Address(String detail) {
this.detail = detail;
}
public String getDetail() {
return detail;
}
@Override
public int hashCode() {
return detail.hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj instanceof Address) {
Address address = (Address) obj;
if (this.getDetail().equals(address.getDetail())) {
return true;
}
}
return false;
}
}

但是值得注意的是，该类的属性虽然是被final修饰的，但若属性是非String的其他引用类型的话，那么虽然该属性的内容（所指对象的地址）不会改变，但其指向的对象却有可能会改变，这样的类当然并不能成为不可变类。比如下面的Person类中有一个Name类型的属性：

[java] view plain copy

package com.home;
public class Person {
private final Name name;
public Person(Name name) {
super();
this.name = name;
}
public Name getName() {
return name;
}
public static void main(String[] args) {
Name n = new Name("三", "张");
Person p = new Person(n);
System.out.println(p.getName().getFirstName());
// 改变Person对象Name属性的firstName属性值
n.setFirstName("无忌");
System.out.println(p.getName().getFirstName());
}
}

Name：

[java] view plain copy

package com.home;
public class Name {
private String firstName;
private String lastName;
public Name() {
super();
}
public Name(String firstName, String lastName) {
super();
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
}

运行上面程序可以看到，Person对象的Name属性的firstName属性已经被改变，这就违背了不可变类设计的初衷。我们可以采取如下办法来解决，修改Person类如下：

[java] view plain copy

package com.home;
public class Person {
private final Name name;
public Person(Name name) {
super();
// 设置name属性为临时创建的Name对象，该对象的firstName属性和lastName属性
// 与传入的name对象的firstName属性和lastName属性相同
this.name = new Name(name.getFirstName(), name.getLastName());
}
public Name getName() {
// 返回一个匿名对象，该对象的firstName属性和lastName属性
// 与该对象里的name属性的firstName属性和lastName属性相同
return new Name(name.getFirstName(), name.getLastName());
}
public static void main(String[] args) {
Name n = new Name("三", "张");
Person p = new Person(n);
System.out.println(p.getName().getFirstName());
// 改变Person对象Name属性的firstName属性值
n.setFirstName("无忌");
System.out.println(p.getName().getFirstName());
}
}

再次运行程序，发现Person对象的Name属性的firstName属性没有改变了。

另外，由于不可变类的实例的状态不可改变，所以可以很方便地被多个对象所共享，那么如果程序要经常使用相同的不可变类实例，为了减少系统开销，一般要考虑使用缓存机制。下面使用数组作为缓存池来构建一个可以缓存实例的不可变类：

[java] view plain copy

package com.home;
public class CacheImmutale {
private final String name;
private static CacheImmutale[] cache = new CacheImmutale[10];
private static int pos = 0;
public CacheImmutale(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public static CacheImmutale valueOf(String name) {
// 遍历已缓存的对象
for (int i = 0; i < pos; i++) {
// 如果已有相同实例，直接返回该缓存的实例
if (cache[i] != null && cache[i].getName().equals(name)) {
return cache[i];
}
}
// 如果缓冲池已满
if (pos == 10) {
// 把缓存的第一个对象覆盖
cache[0] = new CacheImmutale(name);
pos = 1;
return cache[0];
} else {
// 把新创建的对象缓存起来，pos加1
cache[pos++] = new CacheImmutale(name);
return cache[pos - 1];
}
}
@Override
public int hashCode() {
return name.hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj instanceof CacheImmutale) {
CacheImmutale ci = (CacheImmutale) obj;
if (name.equals(ci.getName())) {
return true;
}
}
return false;
}
public static void main(String[] args) {
CacheImmutale c1 = CacheImmutale.valueOf("hello");
CacheImmutale c2 = CacheImmutale.valueOf("hello");
System.out.println(c1 == c2);// 输出结果为true
}
}

对于缓存的使用，应根据系统需求而定，简单的说，如果某个对象使用的次数不多，重复使用的概率不大，就没必要使用缓存，毕竟缓存的对象也会占用系统内存。如果某个对象需要频换地重复使用，这时就应该使用缓存了。

另外，上面的示例来源疯狂JAVA讲义一书，个人对上面那个Person类里面的属性是引用类型的解决办法存有疑问，他那种办法虽然保证的Person对象的Name属性所指对象的内容没有改变，但Person对象返回的Name属性已经不是同一个属性了，它的地址已发生改变，赋值和返回都是通过new出来的，我个人做了如下改进，觉得更合理：

[java] view plain copy