Clases abstractas en Scala

La abstracción es el proceso para ocultar los detalles internos y mostrar solo la funcionalidad. En Scala, la abstracción se logra mediante el uso de una clase abstracta. El funcionamiento de la clase abstracta de Scala es similar al de la clase abstracta de Java . En Scala, una clase abstracta se construye utilizando la palabra clave abstract . Contiene métodos tanto abstractos como no abstractos y no admite herencias múltiples. Una clase puede extender solo una clase abstracta.
Sintaxis:

abstract class class_name
{
// code..
}

Los métodos abstractos de clase abstracta son aquellos métodos que no contienen ninguna implementación. O en otras palabras, el método que no contiene cuerpo se conoce como método abstracto.
Sintaxis:

def function_name()

Ejemplo:

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

Producción:

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

A continuación se presentan algunas observaciones importantes sobre las clases abstractas en Scala.

• Al igual que Java, en Scala no se nos permite crear la instancia de la clase abstracta. Si intentamos crear objetos de la clase abstracta, el compilador dará un error como se muestra en el siguiente programa.
  Ejemplo:

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

  Producción:

  prog.scala:18: error: la clase miautor es abstracta; no se puede crear una instancia
  var obj = new myauthor()
  ^
  se encontró un error

• En Scala, una clase abstracta también puede contener campos. A estos campos acceden los métodos de la clase abstracta y los métodos de la clase que heredan la clase abstracta. Como se muestra en el siguiente programa.
  Ejemplo:

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

  Producción:

  Portal name: GeeksforGeeks
  Tutorial name: Scala

• Al igual que Java, en Scala, una clase abstracta también puede contener un constructor y se llama a un constructor de una clase abstracta cuando se crea una instancia de una clase heredada. Como se muestra en el siguiente programa.
  Ejemplo:

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

  Producción:

  Author name: Ankita
  Topic name: Abstract class
  

• Una clase abstracta también puede contener solo un método no abstracto. Esto nos permite crear clases que no se pueden instanciar, sino que solo se pueden heredar. Como se muestra en el siguiente programa.
  Ejemplo:

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

  Producción:

  Welcome to GeeksforGeeks
  

• En Scala, una clase abstracta puede contener métodos finales (métodos que no se pueden anular). Por ejemplo, el siguiente programa compila y se ejecuta sin errores. En Scala, el método final se crea utilizando la palabra clave final.
  Ejemplo:

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

  Producción:

  Final method
  

Cuándo usar una clase abstracta en Scala:
una clase abstracta es útil:

• Cuando queremos construir una clase base que necesita argumentos de constructor.
• Cuando nuestro código será llamado desde código Java.

Nota: Los rasgos también se utilizan para lograr la abstracción.