Scala-object扩展抽象类并接受参数

//文件Animal.scala

//文件：Dogspeck，用于某些特定情况（覆盖 基类（val）

然后，此调用有效（调用适用）

myTransformation（（）=>dogspeck（this））

现在我想创建一个更通用的对象，可以传递参数，但我不能

可以从Animal创建一个派生对象，该对象接受一个参数并能够使用apply调用

object TheDog(name: String) extends Animal {

  override val name: String = "Spike"
//...
}

不确定如何隐式调用Animal.apply应用我可以在其中传递参数（名称）的Dog对象

myTransformation（（）=>TheDog（this））

---

截至

*错误的top语句声明*

（我只能理解问题的这一部分）-对象中不能有构造函数，因为

对象

是一个单例，所以应该使用case类（ADT）：

val

和带有

apply

的伴生对象会自动添加到案例类中，因此您无需在

Animal

中定义自己的

apply

<代码>案例类日志（val name:String）与

案例类日志（name:String）

相同

我还使用了

trait

s而不是抽象类：

trait Animal {

    val name: String

    def getSomething: String = {
        "Dog: " + name
    }

}

我不理解你的

TypeClass

类型，但是如果你真的想要类型类：

trait Animal {
  def name: String
}

final case class TheDog(name: String) extends Animal
final case class TheCat(name: String) extends Animal

implicit class RichDog(dog: TheDog){
    def getSomething: String = {
        "Dog" + dog.name
    }
}

implicit class RichCat(cat: TheCat){
    def getSomething: String = {
        "Cat: " + cat.name
    }
}

scala> TheDog("Spike").getSomething
res4_5: String = "DogSpike"
scala> TheCat("Tom").getSomething
res4_6: String = "Cat: Tom"

---

关于调用

apply

“隐式”，我不知道为什么会有人需要它，但是：

trait AnimalFactory[A <: Animal] {

   def apply(name: String)(implicit constructor: String => A) = constructor(name)

}

object TheeeDog extends AnimalFactory[TheDog]

implicit def createDog(name: String) = TheDog(name)

TheeeDog("Spike")

---

如果要向构造函数添加一些参数，只需添加它：

   class AnimalFactory(clazz: SomeClass){
       def doSomething = clazz.name

       def apply(name: String)
   }

   val dogFactory = new AnimalFactory(dogClassDescriptor)
   val catFactory = new AnimalFactory(catClassDescriptor)

   dogFactory("Spike")
   catFactory("Tom")

您甚至可以为factory创建一个factory（我不推荐-此解决方案看起来已经过于复杂）：

但是，如果您可以作为成员或仅在包装器中提供底层

clazz

，还有什么意义呢

  final case class ClazzWrapper[T <: Animal](clazz: SomeClass, animal: T)

final case类ClazzWrapper[T
trait Animal {
  def name: String
}

final case class TheDog(name: String) extends Animal
final case class TheCat(name: String) extends Animal

implicit class RichDog(dog: TheDog){
    def getSomething: String = {
        "Dog" + dog.name
    }
}

implicit class RichCat(cat: TheCat){
    def getSomething: String = {
        "Cat: " + cat.name
    }
}

scala> TheDog("Spike").getSomething
res4_5: String = "DogSpike"
scala> TheCat("Tom").getSomething
res4_6: String = "Cat: Tom"

trait AnimalFactory[A <: Animal] {

   def apply(name: String)(implicit constructor: String => A) = constructor(name)

}

object TheeeDog extends AnimalFactory[TheDog]

implicit def createDog(name: String) = TheDog(name)

TheeeDog("Spike")

  case class TheMouse(name: String)
  object TheMouse{
    def apply(isJerry: Boolean): TheMouse = if (isJerry) TheMouse("Jerry") else TheMouse("NotJerry")
  }

  TheMouse(true)

   class AnimalFactory(clazz: SomeClass){
       def doSomething = clazz.name

       def apply(name: String)
   }

   val dogFactory = new AnimalFactory(dogClassDescriptor)
   val catFactory = new AnimalFactory(catClassDescriptor)

   dogFactory("Spike")
   catFactory("Tom")

   object AnimalFactory{ //please don't use classes for that - avoiding `new` is not their purpose
     def apply(clazz: SomeClass) = new AnimalFactory(clazz)
   }
   val dogFactory = AnimalFactory(dogClassDescriptor)
   //or even `val spike = AnimalFactory(dogClassDescriptor)("Spike")`

  final case class ClazzWrapper[T <: Animal](clazz: SomeClass, animal: T)