Scala中抽象类对象属性修改与“克隆”的优雅实现：从可变状态到不可变模式

abstract class A {
  var dbName: String // 使用了可变变量 var

  def withConfig(db: String): A = {
    var a = this // 直接引用当前实例
    a.dbName = db // 修改当前实例的 dbName
    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) // 预期: TEST，实际输出: TEST2
  }
}

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() 方法，需要 asInstanceOf 转换类型
    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()
}

abstract class A {
  def db: String // 使用 val 定义不可变属性，通过抽象方法暴露
  def withConfig(db: String): A // 返回一个新对象
}

class A1(val db: String) extends A { // 构造函数参数直接作为 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 Test {
  def main(args: Array[String]): Unit = {
    val obj = new A1("TEST") // 使用 val 定义不可变引用
    println(obj.db) // 输出: TEST
    val newObj = obj.withConfig("TEST2") // 调用 withConfig 返回新对象
    println(newObj.db) // 输出: TEST2
    println(obj.db) // 输出: TEST (原始对象未被修改)
  }
}

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

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

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

object TestImproved {
  def main(args: Array[String]): Unit = {
    val obj1 = new A1("TEST_A1")
    val obj1Updated: A1 = obj1.withConfig("TEST2_A1") // 编译器知道 obj1Updated 是 A1 类型
    println(obj1Updated.db)

    val obj2 = new A2("TEST_A2")
    val obj2Updated: A2 = obj2.withConfig("TEST2_A2") // 编译器知道 obj2Updated 是 A2 类型
    println(obj2Updated.db)
  }
}

// build.sbt 中需要添加宏相关的依赖，例如：
// scalaVersion := "2.13.12"
// libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value
// addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.1" cross CrossVersion.full) // Scala 2.12/2.11

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) => TypeName(name.toString) // 处理类型参数
        }

        // 查找构造函数中的参数，以便用于 new $tpname(...)
        // 假设只有一个参数列表，且参数名与 withConfig 的参数名不冲突
        val constructorParams = paramss.headOption.map(_.map {
          case q"$_ val $name: $_" => Ident(name)
          case q"$_ var $name: $_" => Ident(name)
          case p: ValDef => Ident(p.name)
        }).getOrElse(List.empty)


        q"""
          $mods class $tpname[..$tparams] $ctorMods(...$paramss) extends { ..$earlydefns } with ..$parents { $self =>
            ..$stats
            override type This = $tpname[..$tparams1]
            override def withConfig(db: String): This = new $tpname(..$constructorParams.head, db) // 假设 db 是第二个参数，需要根据实际情况调整
          }

          ..$tail
        """
    }
  }
}

// 抽象类 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

// 编译后，A1 和 A2 会自动拥有以下代码：
// class A1(val db: String) extends A {
//   override type This = A1
//   override def withConfig(db: String): This = new A1(db)
// }
// class A2(val db: String) extends A {
//   override type This = A2
//   override def withConfig(db: String): This = new A2(db)
// }