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（）并且“等于”新的Foo，你可以替代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。

所以我做了一个新的例子，我们在实例中“猴子补丁”的特性实际上使用了实例：

// --------- 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[Elf]("Xerxes")）。

// ----- 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)

打印：

我是Xerxes，精灵。

与工厂一起使用特征

4 个答案: