我创建了一个带有日期字段的不可变类。我如何确保即使日期字段也是不可变的，因为即使您将日期字段设为最终字段，您以后仍然可以为其分配不同的值？
【问题讨论】：
标签： java immutability
在您的 getDate() 方法中，返回一个 new Date() 实例，而不是同一个实例。
public Date getDate() {
// Not correct.
return this.date; // This will make your class mutable.
// Instead use,
return new Date(this.date.getTime()); // This will make sure your date field cannot be changed.
}
【讨论】：
public Constructor(Date d){ this.date = new Date(d.getTime());}，这样如果对 d 对象进行更改也不会影响原始对象中的日期。
其他答案在显示修复对象中的值的策略时是正确的。
我还建议您使用现代的 java.time 类，而不是糟糕的遗留类。代替Date，使用Instant。代替Calendar，使用ZonedDateTime。
java.time 类被设计为不可变对象。 诸如 plus…、minus…、to… 和 with 等方法都会产生一个新鲜的物体，保持原样不变。这些类不携带 setter 方法。
额外提示：在您自己的不可变类中，您可能会发现遵循 java.time 类建立的方法命名模式很有用。
java.time 框架内置于 Java 8 及更高版本中。这些类取代了麻烦的旧 legacy 日期时间类，例如 java.util.Date、Calendar 和 SimpleDateFormat。
Joda-Time 项目现在位于maintenance mode，建议迁移到java.time 类。
要了解更多信息，请参阅Oracle Tutorial。并在 Stack Overflow 上搜索许多示例和解释。规格为JSR 310。
使用符合JDBC 4.2 或更高版本的JDBC driver，您可以直接与您的数据库交换java.time 对象。不需要字符串也不需要 java.sql.* 类。
从哪里获得 java.time 类？
ThreeTen-Extra 项目通过附加类扩展了 java.time。该项目是未来可能添加到 java.time 的试验场。您可以在这里找到一些有用的类，例如Interval、YearWeek、YearQuarter 和more。
【讨论】：
您可以克隆日期对象，使其无法修改
public Date getDate (){
return (Date) this.date.clone ();
}
【讨论】：
这是Java中immutable类的简单示例
public final class Employee{
final String pancardNumber;
public Employee(String pancardNumber){
this.pancardNumber=pancardNumber;
}
public String getPancardNumber(){
return pancardNumber;
}
}
上面的类是不可变的，因为：
这些点使这个类成为不可变的。对于Date 属性，您可以使用构造函数为每个新对象设置日期并导入org.joda.time.DateTime 类。这是一个比java.util.Date 更好的版本，因为它是不可变的。使用 java.util.Date 会很危险，因为它是一个可变类，我们无法控制调用线程（它可能会修改它）。这是一个例子。
public final class Bill {
private final int amount;
private final DateTime dateTime;
public Bill(int amount, DateTime dateTime) {
this.amount = amount;
this.dateTime = dateTime;
}
public int getAmount() {
return amount;
}
public DateTime getDateTime() {
return dateTime;
}
}
【讨论】：
这是一个带有不可变 HAS-A 日期对象的 Bean(Class) 示例。
import java.util.Date;
public class MyBean {
private Date date; // Immutable Date Step 1 Make Private
public MyBean(Date date)
{
// Immutable Date Step 2 If Set through Constructor then get a specialised (sub class) Date.
this.date= getImmutableDate(date); // THIS METHOD RETURNS AN IMMUTABLE DATE
}
public MyBean(){} // Allow Default Constructor
public Date getDate() {
return date;
}
// Immutable Date Step 3- Allow setting of date only once!!
public void setDate(Date date) {
if(this.date==null)
{
this.date= getImmutableDate(date);
}
}
/* Override all Setter methods of Date class. So even if user gets reference of Date Object it is not the original date object
* it would be a modified date object whose all setter methods do nothing*/
private Date getImmutableDate(Date date)
{
/* This is an Anonymous Inner Class that extends java.util.Date class, it overrides all the setter methods
* making the date object IMMUTABLE( i.e setXXX has no effect)
* */
date =new Date(date.getTime()){
private static final long serialVersionUID = 1L;
@Override
public void setYear(int year) {}
@Override
public void setMonth(int month) {}
@Override
public void setDate(int date) {}
@Override
public void setHours(int hours) {}
@Override
public void setMinutes(int minutes) {}
@Override
public void setSeconds(int seconds) {}
@Override
public void setTime(long time) {}
};
return date;
}
}
【讨论】：
使用防御性复制。这意味着如果您必须将日期传递给其他类，例如通过方法参数或从方法返回，您应该制作一个副本。
复制日期很容易：
new Date(myDate.getting())
【讨论】：
识别可变实例变量（如日期或哈希图）返回具有所有可变对象的复制内容的新对象。不可变变量可以安全返回，无需额外努力。
见下例：
import java.util.Date;
public final class ImmutableClass
{
/**
* Integer class is immutable as it does not provide any setter to change its content
* */
private final Integer immutableField1;
/**
* String class is immutable as it also does not provide setter to change its content
* */
private final String immutableField2;
/**
* Date class is mutable as it provide setters to change various date/time parts
* */
private final Date mutableField;
//Default private constructor will ensure no unplanned construction of class
private ImmutableClass(Integer fld1, String fld2, Date date)
{
this.immutableField1 = fld1;
this.immutableField2 = fld2;
this.mutableField = new Date(date.getTime());
}
//Factory method to store object creation logic in single place
public static ImmutableClass createNewInstance(Integer fld1, String fld2, Date date)
{
return new ImmutableClass(fld1, fld2, date);
}
//Provide no setter methods
/**
* Integer class is immutable so we can return the instance variable as it is
* */
public Integer getImmutableField1() {
return immutableField1;
}
/**
* String class is also immutable so we can return the instance variable as it is
* */
public String getImmutableField2() {
return immutableField2;
}
/**
* Date class is mutable so we need a little care here.
* We should not return the reference of original instance variable.
* Instead a new Date object, with content copied to it, should be returned.
* */
public Date getMutableField() {
return new Date(mutableField.getTime());
}
@Override
public String toString() {
return immutableField1 +" - "+ immutableField2 +" - "+ mutableField;
}
}
更多详情： http://www.javainterviewpoint.com/make-class-immutable-java/
【讨论】：
这样做的唯一方法。 创建一个自定义 DateClass 并覆盖 set** 方法，并且不为此方法提供任何功能。
【讨论】：