在工厂中使用特征

Question

我目前正在探索 scala，我想知道是否可以在工厂中使用特征。

我尝试了这个：

abstract class Foo {
  ...
}
object Foo {
  def apply() = new Bar

  private class Bar extends Foo {
    ...
  }
}

Foo() with MyTrait // Not working

我想这是因为 with 前面必须有 new 。

那么有什么办法可以做到这一点吗？

谢谢

Answer 1

不，已经太晚了，当 apply() 方法返回时实例已经创建了。

您可以做的是使用工厂方法内的特征。下面的代码来自我正在编写的一个相当大的代码示例：

object Avatar {
 // Avatar factory method
 def apply(name: String, race: RaceType.Value, character: CharacterType.Value
  ): Avatar = {
    race match {
      case RaceType.Dwarf => {
        character match {
          case CharacterType.Thief => new Avatar(name) with Dwarf with Thief
          case CharacterType.Warrior => new Avatar(name) with Dwarf with Warrior
          case CharacterType.Wizard => new Avatar(name) with Dwarf with Wizard
        }
      }
      case RaceType.Elf => {
        character match {
          case CharacterType.Thief => new Avatar(name) with Elf with Thief
          case CharacterType.Warrior => new Avatar(name) with Elf with Warrior
          case CharacterType.Wizard => new Avatar(name) with Elf with Wizard
        }
      }
    }
  }
}

class Avatar(val name: String) extends Character {
  ...
}

在这段代码中，你的头像的类型（职业和种族）是在工厂中根据 RaceType 和 CharacterType 枚举决定的。您拥有的是用于各种不同类型或类型组合的一个工厂。

Answer 2

假设你有：

class Foo
object Foo { def apply() = new Foo }
trait Baz

那么：

Foo() with Baz

类似于：

val foo = new Foo
foo with Baz

这意味着某种基于原型的继承，而 Scala 没有。 （据我所知。）

（我猜思维中的错误是直观地将 = 符号误认为是“替换符号”。即，因为 Foo() 意味着 Foo.apply() 并且“等于” new Foo，所以你可以用 new Foo 代替 Foo() ，但显然不能。）

Answer 3

隐式转换解决方案

Ken 建议代理可以在这种情况下为我们提供帮助。我们在这里尝试做的是在创建实例后向其添加特征。如果其他人编写了该类（以及 apply() 方法）并且您无法访问源代码，则这种“猴子修补”可能会很有用。在这种情况下，您可以通过隐式转换在实例顶部添加代理/包装器（无需手动转换）：

---

使用 Foo 示例，我们可以这样做：

class Foo
object Foo { def apply() = new Foo }
trait Baz { def usefulMethod(s: String) = "I am really useful, "+ s }

// ---- Proxy/Wrapper ----
class FooWithBazProxy extends Foo with Baz

// --- Implicit conversion ---
implicit def foo2FooWithBazProxy(foo: Foo): FooWithBazProxy = new FooWithBazProxy

// --- Dummy testcode ---
val foo = Foo()
println(foo.usefulMethod("not!"))

输出：

I am really useful, not! 

我的原因不喜欢这个例子的是：

Baz 不以任何方式使用 Foo。很难看出为什么我们要将 usefulMethod() 附加到 Foo。

---

所以我做了一个新的例子，其中我们“实例中的“monkey patch”实际上使用了该实例：

// --------- Predefined types -----------
trait Race {
  def getName: String
}

class Avatar(val name: String) extends Race{
  override def getName = name
}

object Avatar{ 
  def apply() = new Avatar("Xerxes")
}

// ---------- Your new trait -----------
trait Elf extends Race {
  def whoAmI = "I am "+ getName + ", the Elf. "
}

// ---- Proxy/Wrapper ----
class AvatarElfProxy(override val name: String) extends Avatar(name) with Elf

// ---- Implicit conversion ----
implicit def avatar2AvatarElfProxy(Avatar: Avatar): AvatarElfProxy = new AvatarElfProxy(Avatar.name)


// --- Dummy testcode ---
val xerxes= Avatar()
println(xerxes.whoAmI)

打印：

I am Xerxes, the Elf.

在此示例中，添加的 Elf 特征使用其扩展的实例的 getName 方法。

如果您看到任何错误，我将不胜感激，我还不擅长隐式。

Answer 4

使用代理和隐式转换的解决方案

此示例扩展了 olle 的解决方案，允许用户在调用 apply() 方法时指定 mixin 特征（例如 val xerxes = Avatar [精灵](“薛西斯”))。

// ----- Predefined types -----

trait Race {
   def whoAmI: String
}

class Avatar[R <: Race](val name: String) 

object Avatar {
   def apply[R <: Race](name: String) = new Avatar[R](name)
}

// ----- Generic proxy -----
class AvatarProxy[R <: Race](val avatar: Avatar[R])

implicit def proxy2Avatar[R <: Race](proxy: AvatarProxy[R]): Avatar[R] = 
      proxy.avatar

// ----- A new trait -----
trait Elf extends Race {
   self: AvatarProxy[Elf] =>
   def whoAmI = "I am " + self.name + ", the Elf."
}

implicit def avatar2Elf(avatar: Avatar[Elf]): AvatarProxy[Elf] with Elf = 
      new AvatarProxy[Elf](avatar) with Elf

// --- Test code -----
val xerxes = Avatar[Elf]("Xerxes")
println(xerxes.whoAmI)

印刷：

我是精灵薛西斯。