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

abstract class A {
  var dbName: String // 使用 var 表示可变状态

  def withConfig(db: String): A = {
    var a = this // 直接引用当前对象
    a.dbName = db // 修改当前对象的成员
    a
  }
}

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

object Test {
  def main(args: Array[String]): Unit = {
    var obj = new A1("TEST")
    println(s"Original obj dbName: ${obj.dbName}") // 输出: TEST

    var newObj = obj.withConfig("TEST2")
    println(s"New obj dbName: ${newObj.dbName}")   // 输出: TEST2
    println(s"Original obj dbName after update: ${obj.dbName}") // 输出: TEST2
  }
}

abstract class A {
  var dbName: String

  def withConfig(db: String): A = {
    // 尝试克隆当前对象
    var a = this.clone().asInstanceOf[A] // 注意：这里会抛出异常
    a.dbName = db
    a
  }
}

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

abstract class A extends Cloneable { // 混入 Cloneable 特质
  var dbName: String

  def withConfig(db: String): A = {
    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) // 同理
}

object TestClone {
  def main(args: Array[String]): Unit = {
    var obj = new A1("TEST")
    println(s"Original obj dbName: ${obj.dbName}") // TEST

    var newObj = obj.withConfig("TEST2")
    println(s"New obj dbName: ${newObj.dbName}")   // TEST2
    println(s"Original obj dbName after update: ${obj.dbName}") // TEST
  }
}

Original obj dbName: TEST
New obj dbName: TEST2
Original obj dbName after update: TEST

abstract class A {
  def db: String // 使用 val，因此是不可变的
  def withConfig(newDb: String): A // 返回一个带有新配置的新实例
}

class A1(val db: String) extends A { // db 是 val
  override def withConfig(newDb: String): A = new A1(newDb) // 返回 A1 的新实例
}

class A2(val db: String) extends A { // db 是 val
  override def withConfig(newDb: String): A = new A2(newDb) // 返回 A2 的新实例
}

object TestImmutable {
  def main(args: Array[String]): Unit = {
    val obj = new A1("TEST") // 使用 val
    println(s"Original obj db: ${obj.db}") // TEST

    val newObj = obj.withConfig("TEST2")
    println(s"New obj db: ${newObj.db}")   // TEST2
    println(s"Original obj db after update: ${obj.db}") // TEST
  }
}

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

class A1(val db: String) extends A {
  override type This = A1 // 在 A1 中，This 具体化为 A1
  override def withConfig(newDb: String): This = new A1(newDb) // 返回 A1 的实例
}

class A2(val db: String) extends A {
  override type This = A2 // 在 A2 中，This 具体化为 A2
  override def withConfig(newDb: String): This = new A2(newDb) // 返回 A2 的实例
}

object TestPathDependentType {
  def main(args: Array[String]): Unit = {
    val obj: A1 = new A1("TEST") // obj 的类型是 A1
    val newObj = obj.withConfig("TEST2") // newObj 的类型现在也是 A1，无需 asInstanceOf
    println(s"New obj type: ${newObj.getClass.getName}") // 输出: ...A1
  }
}

// build.sbt 中需要添加 macro paradise 插件
// addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full)
// libraryDependencies += "org.scala-lang" % "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 q"$mods val $name: $tpt" => tq"$name" // 捕获 val 参数作为类型的一部分，如果类是泛型
          case tparam => tparam // 其他情况直接返回
        } match {
          case Nil => List(tpname) // 如果没有类型参数，则直接使用类名
          case _ => tparams.map { case q"$mods type $tpname[..$_] = $_" => tq"$tpname" case other => other } // 提取类型参数名称
        }
        val constructorParams = paramss.headOption.getOrElse(List()).map {
          case q"$_ val $name: $tpt = $_" => q"$name" // 提取构造函数参数名
          case q"$_ $name: $tpt = $_" => q"$name"
        }

        q"""
          $mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self =>
            ..$stats
            override type This = $tpname[..$tparams1] // 生成 override type This
            override def withConfig(db: String): This = new $tpname(..$constructorParams) { // 生成 override def withConfig
              override val db: String = db // 假设 db 是构造函数的第一个参数或可访问的 val
            }
          }

          ..$tail
        """
    }
  }
}

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