本文探讨了在scala抽象类中安全地创建对象副本并修改其特定成员值的策略。针对直接赋值修改原对象和`clone()`方法抛出异常的问题，文章详细介绍了通过实现`cloneable`接口重写`clone`方法、采用不可变对象与`val`构建新实例（scala推荐范式），以及利用`type this`提升类型精度等多种解决方案。旨在提供清晰、实用的指南，帮助开发者在保持原对象不变的前提下，高效地实现对象状态的灵活管理。
1. 问题背景与初始尝试
在Scala中，当我们需要从一个现有对象创建一个“副本”并修改其部分属性时，常见的需求是希望原对象保持不变。然而，直接在抽象类方法中对 this 实例进行操作并尝试修改其成员，会导致原对象也随之改变，这与我们创建副本的初衷相悖。
考虑以下示例代码：
abstract class A {
var dbName: String // 使用var定义可变属性
def withConfig(db: String): A = {
var a = this // 'a' 引用了当前的this实例
a.dbName = db // 直接修改了原对象的dbName
a
}
}
class A1(db: String) extends A {
override var dbName: String = db
}
object TestInitial {
def main(args: Array[String]): Unit = {
var obj = new A1("TEST")
println(s"Original dbName before modification: ${obj.dbName}") // Output: TEST
var newObj = obj.withConfig("TEST2")
println(s"New object dbName: ${newObj.dbName}") // Output: TEST2
println(s"Original dbName after modification: ${obj.dbName}") // Output: TEST2 (原对象被修改)
}
}运行上述代码会发现，obj 的 dbName 在 withConfig 调用后也被修改为 "TEST2"，这并非期望的行为。
为了解决这个问题，开发者可能会尝试使用 java.lang.Object 的 clone() 方法来创建对象的副本。然而，直接调用 this.clone() 通常会导致 CloneNotSupportedException：
abstract class A {
var dbName: String
def withConfig(db: String): A = {
var a = this.clone().asInstanceOf[A] // 尝试克隆，但会抛出异常
a.dbName = db
a
}
}
// ... (A1, A2 class definitions remain the same)
// 运行将抛出:
// Exception in thread "main" java.lang.CloneNotSupportedException: c.i.d.c.A1这是因为 java.lang.Object.clone() 是一个 protected 的本地方法，并且要求类实现 java.lang.Cloneable 接口，同时通常需要在子类中重写 clone() 方法并将其访问权限提升为 public。
2. 解决方案一：Java Cloneable 接口与 clone 方法重写
解决 CloneNotSupportedException 的方法是让抽象类及其所有具体子类实现 java.lang.Cloneable 接口，并在每个具体子类中重写 clone() 方法。重写的 clone() 方法应返回该类的一个新实例，以实现浅拷贝。
abstract class A extends Cloneable { // 抽象类A需要继承Cloneable接口
var dbName: String
def withConfig(db: String): A = {
// 调用clone()方法，并强制转换为A类型
var a = this.clone().asInstanceOf[A]
a.dbName = db // 修改新对象的dbName
a
}
}
class A1(db: String) extends A {
override var dbName: String = db
// 在具体子类中重写clone()方法，返回一个该类的新实例
override def clone(): AnyRef = new A1(db)
}
class A2(db: String) extends A {
override var dbName: String = db
override def clone(): AnyRef = new A2(db)
}
object TestCloneable {
def main(args: Array[String]): Unit = {
var obj = new A1("TEST")
println(s"Original dbName: ${obj.dbName}") // Output: Original dbName: TEST
var newObj = obj.withConfig("TEST2")
println(s"New object dbName: ${newObj.dbName}") // Output: New object dbName: TEST2
println(s"Original dbName after withConfig: ${obj.dbName}") // Output: Original dbName after withConfig: TEST
}
}注意事项:
- 所有希望被克隆的类及其父类都需要实现 Cloneable 接口。
- clone() 方法默认返回 AnyRef，需要进行类型转换。
- 这种方法创建的是浅拷贝。如果对象内部包含可变引用类型成员，则需要实现深拷贝逻辑，这会增加复杂性。
- 在Scala中，使用 var 变量通常被认为不是最符合函数式编程范式的做法，更推荐使用不可变数据结构。
3. 解决方案二：优先使用不可变对象和 val (推荐的Scala范式)
Scala鼓励使用不可变对象和 val 关键字，这与函数式编程范式更为契合。在这种模式下，当需要修改对象状态时，不是直接修改原对象，而是创建一个带有新状态的新对象。这种方式天然地解决了原对象被修改的问题，且避免了 Cloneable 接口的复杂性。
abstract class A {
def db: String // 使用val或def定义不可变属性
def withConfig(db: String): A // 返回一个新A实例
}
class A1(val db: String) extends A { // db作为val参数，使其不可变
override def withConfig(db: String): A = new A1(db) // 返回一个A1的新实例
}
class A2(val db: String) extends A {
override def withConfig(db: String): A = new A2(db) // 返回一个A2的新实例
}
object TestImmutable {
def main(args: Array[String]): Unit = {
val obj = new A1("TEST")
println(s"Original db: ${obj.db}") // Output: Original db: TEST
val newObj = obj.withConfig("TEST2")
println(s"New object db: ${newObj.db}") // Output: New object db: TEST2
println(s"Original db after withConfig: ${obj.db}") // Output: Original db after withConfig: TEST
}
}优点:
- 不可变性: 保证了对象一旦创建，其状态就不会改变，简化了并发编程和代码推理。
- 简洁性: 无需实现 Cloneable 接口，代码更简洁、更符合Scala范式。
- 安全性: 避免了意外修改原对象的风险。
4. 解决方案三：提升类型精度：使用 type This
在上述不可变模式中，withConfig 方法返回的是抽象类型 A。这在某些情况下可能不够精确，例如，当你调用 obj.withConfig("...") 时，你可能期望得到一个 A1 类型的对象，而不是一个通用的 A 类型。通过引入 type This，我们可以让 withConfig 方法返回更具体的类型。
