斯卡拉 |特征混合

我们可以使用已知为trait Mixins的类或抽象类扩展多个 scala 特征。值得知道的是，我们只能扩展特征或特征与类的混合或特征与抽象类的混合。这里甚至必须维护 trait Mixins的序列，否则编译器会抛出错误。
笔记：

1. Mixins 特征用于组成一个类。
2. 一个 Class 几乎不能有一个单一的超类，但它可以有许多 trait Mixin。超类和特征 Mixins 可能具有相同的超类型。

现在，让我们看一些例子。

• 用 trait 扩展抽象类
  例子 ：

  // Scala program of trait Mixins
    
  // Trait structure
  trait Display
  { 
    
      def Display() 
  } 
    
  // An abstract class structure
  abstract class Show
  { 
      def Show() 
  } 
    
  // Extending abstract class with
  // trait
  class CS extends Show with Display
  {
        
      // Defining abstract class
      // method
      def Display()
      {     
          // Displays output
          println("GeeksforGeeks") 
      } 
        
      // Defining trait method
      def Show()
      {                                     
          // Displays output 
          println("CS_portal") 
      } 
  }
    
  // Creating object
  object GfG
  { 
      // Main method
      def main(args:Array[String])
      { 
            
          // Creating object of class CS
          val x = new CS() 
            
          // Calling abstract method
          x.Display() 
            
          // Calling trait method
          x.Show() 
      } 
  } 
  

  输出：

  GeeksforGeeks
  CS_portal
  

  在这里，Mixins 的正确顺序是，我们需要先扩展任何类或抽象类，然后使用关键字with扩展任何 trait。

• 扩展没有特征的抽象类
  例子 ：

  // Scala program of trait Mixins
    
  // Trait structure
  trait Text
  { 
      def txt() 
  }
    
  // An abstract class structure
  abstract class LowerCase
  { 
      def lowerCase() 
  } 
    
  // Extending abstract class 
  // without trait
  class Myclass extends LowerCase
  {
        
      // Defining abstract class
      // method
      def lowerCase()
      { 
          val y = "GEEKSFORGEEKS"
            
          // Displays output
          println(y.toLowerCase()) 
      } 
        
      // Defining trait method
      def txt()
      {                                     
        
          // Displays output 
          println("I like GeeksforGeeks") 
      } 
  } 
    
  // Creating object
  object GfG
  { 
      // Main method
      def main(args:Array[String])
      { 
            
          // Creating object of 'Myclass'
          // with trait 'Text'
          val x = new Myclass() with Text
            
          // Calling abstract method
          x.lowerCase() 
            
          // Calling trait method
          x.txt() 
      } 
  } 
  

  输出：

  geeksforgeeks
  I like GeeksforGeeks
  

  因此，从这个例子中我们可以说特征甚至可以在创建对象时进行扩展。
  注意：如果我们先扩展一个 trait，然后再扩展抽象类，那么编译器会抛出一个错误，因为这不是 trait Mixins 的正确顺序。