algorithm - 扩展动态特质？

我是scala的新手，我不知道该如何回答这个问题，但基本上我知道：

   trait Hi {
      protected val hi : String = "Hi"

   }

   trait HowAre {
      protected val howare : String = "How Are you?"

   }

   trait Text{
     protected val text :String = "Any Text"
   }

   class SeeText () extends Text {

     def SeeString() = {
        println(text)
     }

   }

   class SeeHi () extends Hi {

     def SeeString() = {
        println(hi)
     }

   }

   class SeeHowAre () extends HowAre {

     def SeeString() = {
        println(howare)
     }

   }

我在每个类中都有相同的函数来显示字符串，我不想这样，我想使用一个只有一个函数的类来显示字符串，我想：

   trait Hi {
      protected val hi : String = "Hi"
      def getString() : String = {hi}

   }

   trait HowAre {
      protected val howare : String = "How Are you?"
       def getString() : String = {howare}

   }

   trait Text{
     protected val text :String = "Any Text"
       def getString() : String = {text}
   }

   class SeeGeneral() extends Text with Hi with HowAre{
        def SeeString()={
          println( getString() )
        }
   }

但如何控制字符串的显示类可以动态地扩展单个特征吗我们的想法不是为每个特性创建一个类，也不是编写更多的代码，谢谢

最佳答案

您可以创建实现getString()的基本特征，并让所有特征扩展该特征：

trait SupportsGetString {
  def getString: String
}

trait Hi extends SupportsGetString {
  protected val hi : String = "Hi"
  def getString() : String = {hi}

}

trait HowAre extends SupportsGetString  {
  protected val howare : String = "How Are you?"
  def getString() : String = {howare}
}

trait Text extends SupportsGetString {
  protected val text :String = "Any Text"
    def getString() : String = {text}
}

然后，您的通用函数可以接受基本特征的实例。

def seeString(a: SupportsGetString) = a.getString

有时候，你不能有一个共享的基类也许，也许你的一个特质是由第三方提供的，是无法改变的当这种情况发生时，您可以使用类型类。此技术允许您描述从类型外部的类型A中提取字符串的行为：

// A trait that knows how to get some inner string from a type A
trait GetString[A] {
  def getString(a: A): String
}

现在，让我们为您拥有的类型定义一些此特征的值：

object GetString {
    implicit val hiGetString: GetString[Hi] = new GetString[Hi] {
        def getString(a: Hi): String = a.hi
    }
    implicit val howAreGetString: GetString[HowAre] = new GetString[HowAre] {
        def getString(a: HowAre): String = a.howare
    }
}

现在，您可以编写一个函数，从任何A中获取一个字符串，您有一个隐式GetString[A]用于：

def getIt[A](a: A)(implicit getter: GetString[A]): String =
    getter.getString(a)