Scala 中的抽象类

抽象是隐藏内部细节并仅显示功能的过程。在 Scala 中，抽象是通过使用抽象类来实现的。 Scala 抽象类的工作方式类似于Java抽象类。在 Scala 中，抽象类是使用abstract 关键字构造的。它包含抽象和非抽象方法，不能支持多重继承。一个类只能扩展一个抽象类。
句法：

abstract class class_name
{
// code..
}

抽象类的抽象方法是那些不包含任何实现的方法。或者换句话说，不包含主体的方法称为抽象方法。
句法：

def function_name()

例子：

// Scala program to illustrate how to 
// create an abstract class
  
// Abstract class
abstract class myauthor
{
      
    // abstract method
    def details()
}
  
// GFG class extends abstract class
class GFG extends myauthor
{
    def details()
    {
        println("Author name: Ankita Saini")
        println("Topic name: Abstract class in Scala")
    }
}
  
object Main 
{
    // Main method
    def main(args: Array[String]) 
    {
        // objects of GFG class
        var obj = new GFG()
        obj.details()
    }
}

输出：

Author name: Ankita Saini
Topic name: Abstract class in Scala

以下是关于 Scala 中抽象类的一些重要观察。

• 像Java一样，在 Scala 中，我们不允许创建抽象类的实例。如果我们尝试创建抽象类的对象，那么编译器将给出错误，如下面的程序所示。
  例子：

  // Scala program to illustrate 
  // the concept of abstract class
    
  // Abstract class
  abstract class myauthor{
        
      // abstract method
      def details()
  }
    
    
  object Main {
        
      // Main method
      def main(args: Array[String]) {
            
          // Object of myauthor class
      var obj = new myauthor()
      }
  }
  

  输出：

  prog.scala:18: error: class myauthor is abstract; cannot be instantiated
  var obj = new myauthor()
  ^
  one error found

• 在 Scala 中，抽象类也可以包含字段。这些字段由抽象类方法和继承抽象类的类的方法访问。如以下程序所示。
  例子：

  // Scala program to illustrate 
  // the concept of abstract class
    
  // Abstract class with fields
  abstract class Geek
  {
      var name : String = "GeeksforGeeks"
      var tutorial: String = "Scala"
      def portal()
  }
    
  // GFG class extends abstract class
  class GFG extends Geek
  {
        
      // Abstract class method accessing
      // fields of the abstract class
      def portal()
      {
          println("Portal name: " + name)
            
      }
        
      // GFG class method accessing 
      // fields of the abstract class
      def tutdetails()
      {
          println("Tutorial name: " + tutorial) 
      }
  }
    
  object Main 
  {
        
      // Main method
      def main(args: Array[String]) 
      {
            
          // objects of GFG class
          var obj = new GFG()
          obj.portal()
          obj.tutdetails()
      }
  }
  

  输出：

  Portal name: GeeksforGeeks
  Tutorial name: Scala

• 与Java一样，在 Scala 中，抽象类也可以包含构造函数，并且在创建继承类的实例时会调用抽象类的构造函数。如以下程序所示。
  例子：

  // Scala program to illustrate 
  // the concept of abstract class
    
  // Abstract class with constructor
  // And the constructor contain two arguments
  abstract class myauthor(name: String,
                          topic: String)
  {
      def details()
  }
    
  // GFG class extends abstract class
  class GFG(name: String, topic: String) extends
                              myauthor(name, topic)
  {
      def details()
      {
          println("Author name: " + name)
          println("Topic name: " + topic)
      }
  }
    
  object Main 
  {
        
      // Main method
      def main(args: Array[String])
      {
            
          // objects of GFG class
          var obj = new GFG("Ankita", "Abstract class")
          obj.details()
      }
  }
  

  输出：

  Author name: Ankita
  Topic name: Abstract class
  

• 抽象类也可以只包含非抽象方法。这允许我们创建无法实例化但只能被继承的类。如以下程序所示。
  例子：

  // Scala program to illustrate 
  // the concept of abstract class
    
  // Abstract class with 
  // non-abstract method
  abstract class myauthor
  {
        
      // Non-abstract method
      def details()
      {
          println("Welcome to GeeksforGeeks")
      }
  }
    
  // GFG class extends abstract class
  class GFG extends myauthor{}
    
  object Main 
  {
        
      // Main method
      def main(args: Array[String])
      {
            
          // objects of GFG class
          var obj = new GFG()
          obj.details()
      }
  }
  

  输出：

  Welcome to GeeksforGeeks
  

• 在 Scala 中，抽象类可以包含最终方法（不能被覆盖的方法）。例如，下面的程序编译并运行没有错误。在 Scala 中，final 方法是使用 final 关键字创建的。
  例子：

  // Scala program to illustrate 
  // the concept of abstract class
    
  // Abstract class with the final method
  abstract class myauthor
  {
      final def mymethod()
      {
          println("Final method")
      }
  }
    
  // GFG class extends abstract class
  class GFG extends myauthor{}
    
  object Main 
  {
        
      // Main method
      def main(args: Array[String]) 
      {
            
          // objects of GFG class
          var obj = new GFG()
          obj.mymethod()
      }
  }
  

  输出：

  Final method
  

何时在 Scala 中使用抽象类：
抽象类很有用：

• 当我们想要构造一个需要构造函数参数的基类时。
• 当我们的代码将从Java代码中调用时。

注意：特征也用于实现抽象。