在Scala抽象类中实现对象克隆与不可变更新的策略

abstract class A {
  var dbName: String // 可变成员

  // 初次尝试：直接修改this
  def withConfig(db: String): A = {
    var a = this // 引用原始对象
    a.dbName = db // 修改原始对象
    a
  }
}

class A1(db: String) extends A {
  override var dbName: String = db
}

class A2(db: String) extends A {
  override var dbName: String = db
}

object Test {
  def main(args: Array[String]): Unit = {
    var obj = new A1("TEST")
    println(obj.dbName) // TEST
    var newObj = obj.withConfig("TEST2")
    println(newObj.dbName) // TEST2
    println(obj.dbName) // TEST2 - 原始对象也被修改，这不是我们期望的
  }
}

// 尝试使用clone()
abstract class A {
  var dbName: String

  def withConfig(db: String): A = {
    var a = this.clone().asInstanceOf[A] // 尝试克隆
    a.dbName = db
    a
  }
}
// ... A1, A2 类定义不变 ...

abstract class A extends Cloneable { // 继承Cloneable接口
  var dbName: String

  def withConfig(db: String): A = {
    // 调用clone()，并进行类型转换
    var a = this.clone().asInstanceOf[A]
    a.dbName = db
    a
  }
}

class A1(db: String) extends A {
  override var dbName: String = db
  override def clone(): AnyRef = new A1(db) // 覆盖clone()方法，返回新实例
}

class A2(db: String) extends A {
  override var dbName: String = db
  override def clone(): AnyRef = new A2(db) // 覆盖clone()方法，返回新实例
}

object TestClone {
  def main(args: Array[String]): Unit = {
    var obj = new A1("TEST")
    println(obj.dbName) // TEST
    var newObj = obj.withConfig("TEST2")
    println(newObj.dbName) // TEST2
    println(obj.dbName) // TEST - 原始对象未被修改
  }
}

abstract class A {
  def db: String // 使用val，因此定义为抽象方法
  def withConfig(db: String): A // 返回一个新实例
}

class A1(val db: String) extends A { // val db: String 自动成为字段
  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") // 使用val
    println(obj.db) // TEST
    val newObj = obj.withConfig("TEST2") // 返回新对象
    println(newObj.db) // TEST2
    println(obj.db) // TEST - 原始对象未被修改
  }
}

abstract class A {
  def db: String
  type This <: A // 定义一个类型成员，表示当前对象的具体类型
  def withConfig(db: String): This // 返回类型为This
}

class A1(val db: String) extends A {
  override type This = A1 // 在A1中，This就是A1
  override def withConfig(db: String): This = new A1(db) // 返回A1实例
}

class A2(val db: String) extends A {
  override type This = A2 // 在A2中，This就是A2
  override def withConfig(db: String): This = new A2(db) // 返回A2实例
}

object TestTypeSafe {
  def main(args: Array[String]): Unit = {
    val obj: A1 = new A1("TEST")
    val newObj: A1 = obj.withConfig("TEST2") // newObj的类型被正确推断为A1
    println(newObj.db)
  }
}

// build.sbt 中需要添加对 scala-reflect 的依赖
// libraryDependencies += scalaOrganization.value % "scala-reflect" % scalaVersion.value

import scala.annotation.{StaticAnnotation, compileTimeOnly}
import scala.language.experimental.macros
import scala.reflect.macros.blackbox

@compileTimeOnly("enable macro annotations") // 编译时检查是否启用了宏注解
class implement extends StaticAnnotation {
  def macroTransform(annottees: Any*): Any = macro ImplementMacro.impl
}

object ImplementMacro {
  def impl(c: blackbox.Context)(annottees: c.Tree*): c.Tree = {
    import c.universe._
    annottees match {
      case q"$mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self => ..$stats }" :: tail =>
        // 提取类型参数名称，用于构造This的类型
        val tparams1 = tparams.map {
          case q"$mods type $tpname[..$tparams] = $tpt" => tq"$tpname"
          case TypeDef(mods, name, tps, rhs) => tq"$name" // 处理普通类型参数
          case t => tq"${t.name}" // 兜底处理
        }
        // 构造新的类定义，注入type This和withConfig方法
        q"""
          $mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self =>
            ..$stats // 保留原有成员
            override type This = $tpname[..$tparams1] // 注入This类型
            override def withConfig(db: String): This = new $tpname(db) // 注入withConfig方法
          }
          ..$tail
        """
      case _ => c.abort(c.enclosingPosition, "Annotation can only be applied to classes.")
    }
  }
}

// 抽象类A保持不变
abstract class A {
  def db: String
  type This <: A
  def withConfig(db: String): This
}

@implement // 应用宏注解
class A1(val db: String) extends A

@implement // 应用宏注解
class A2(val db: String) extends A