Herencia en Scala

La herencia es un pilar importante de OOP (Programación Orientada a Objetos). Es el mecanismo en Scala por el cual una clase puede heredar las características (campos y métodos) de otra clase. 
Terminología importante: 
 

• Superclase: la clase cuyas características se heredan se conoce como superclase (o una clase base o una clase principal).
• Subclase: la clase que hereda la otra clase se conoce como subclase (o una clase derivada, una clase extendida o una clase secundaria). La subclase puede agregar sus propios campos y métodos además de los campos y métodos de la superclase.
• Reutilización: la herencia admite el concepto de «reutilización», es decir, cuando queremos crear una nueva clase y ya existe una clase que incluye parte del código que queremos, podemos derivar nuestra nueva clase de la clase existente. Al hacer esto, estamos reutilizando los campos y métodos de la clase existente.
   

Cómo usar la herencia en Scala

La palabra clave utilizada para la herencia se extiende . 
Sintaxis: 
 

class child_class_name extends parent_class_name {
// Methods and fields
}

Ejemplo: 
 

// Scala program to illustrate the
// implementation of inheritance
 
// Base class
class Geeks1{
    var Name: String = "Ankita"
}
 
// Derived class
// Using extends keyword
class Geeks2 extends Geeks1
{
    var Article_no: Int = 130
     
    // Method
    def details()
    {
    println("Author name: " +Name);
    println("Total numbers of articles: " +Article_no);
    }
}
 
object Main
{
     
    // Driver code
    def main(args: Array[String])
    {
         
        // Creating object of derived class
        val ob = new Geeks2();
        ob.details();
    }
}

Producción: 
 

Author name: Ankita
Total numbers of articles: 130

Explicación: En el ejemplo anterior, Geeks1 es la clase base y Geeks2 es la clase derivada que se deriva de Geeks1 usando la palabra clave extends. En el método principal cuando creamos el objeto de la clase Geeks2, una copia de todos los métodos y campos de la clase base adquiere memoria en este objeto. Es por eso que al usar el objeto de la clase derivada también podemos acceder a los miembros de la clase base. 
 

tipo de herencia

A continuación se muestran los diferentes tipos de herencia que admite Scala. 
 

• Herencia única: en la herencia única, la clase derivada hereda las características de una clase base. En la imagen a continuación, la clase A sirve como clase base para la clase B derivada. 
   

• Ejemplo: 
   

// Scala program to illustrate the
// Single inheritance
 
// Base class
class Parent
{
    var Name: String = "Ankita"
}
 
// Derived class
// Using extends keyword
class Child extends Parent
{
    var Age: Int = 22
     
    // Method
    def details()
    {
    println("Name: " +Name);
    println("Age: " +Age);
    }
}
 
object Main
{
     
    // Driver code
    def main(args: Array[String])
    {
         
        // Creating object of the derived class
        val ob = new Child();
        ob.details();
    }
}

• Producción: 
   

Name: Ankita
Age: 22

• Herencia multinivel: en la herencia multinivel, una clase derivada heredará una clase base y, además, la clase derivada también actuará como la clase base para otra clase. En la siguiente imagen, la clase A sirve como clase base para la clase B derivada, que a su vez sirve como clase base para la clase C derivada. 
   

• Ejemplo: 
   

// Scala program to illustrate the
// Multilevel inheritance
 
// Base class
class Parent
{
    var Name: String = "Soniya"
}
 
// Derived from parent class
// Base class for Child2 class
class Child1 extends Parent
{
    var Age: Int = 32
}
 
// Derived from Child1 class
class Child2 extends Child1
{
    // Method
    def details(){
    println("Name: " +Name);
    println("Age: " +Age);
    }
}
 
object Main
{
     
    // Drived Code
    def main(args: Array[String])
    {
         
        // Creating object of the derived class
        val ob = new Child2();
        ob.details();
    }
}

• Producción: 
   

Name: Soniya
Age: 32

• Herencia jerárquica: en la herencia jerárquica, una clase sirve como superclase (clase base) para más de una subclase. En la imagen de abajo, la clase A sirve como clase base para las clases derivadas B, C y D. 
   

• Ejemplo: 
   

// Scala program to illustrate the
// Hierarchical inheritance
 
// Base class
class Parent
{
    var Name1: String = "Siya"
    var Name2: String = "Soniya"
}
 
// Derived from the parent class
class Child1 extends Parent
{
    var Age: Int = 32
    def details1()
    {
    println(" Name: " +Name1);
    println(" Age: " +Age);
    }
}
 
// Derived from Parent class
class Child2 extends Parent
{
    var Height: Int = 164
     
    // Method
    def details2()
    {
    println(" Name: " +Name2);
    println(" Height: " +Height);
    }
}
 
object Main
{
     
    // Driver code
    def main(args: Array[String])
    {
         
        // Creating objects of both derived classes
        val ob1 = new Child1();
        val ob2 = new Child2();
        ob1.details1();
        ob2.details2();
    }
}

• Producción: 
   

 Name: Siya
 Age: 32
 Name: Soniya
 Height: 164

• Herencia múltiple: en herencia múltiple, una clase puede tener más de una superclase y heredar características de todas las clases principales. Scala no admite la herencia múltiple con clases, pero se puede lograr mediante rasgos. 
   

• Ejemplo: 
   

// Scala program to illustrate the
// multiple inheritance using traits
 
// Trait 1
trait Geeks1
{
    def method1()
}
 
// Trait 2
trait Geeks2
{
    def method2()
}
 
// Class that implement both Geeks1 and Geeks2 traits
class GFG extends Geeks1 with Geeks2
{
     
    // method1 from Geeks1
    def method1()
    {
        println("Trait 1");
    }
     
    // method2 from Geeks2
    def method2()
    {
        println("Trait 2");
    }
}
object Main
{
    // Driver code
    def main(args: Array[String])
    {
         
        // Creating object of GFG class
        var obj = new GFG();
        obj.method1();
        obj.method2();
    }
}

• Producción: 

Trait 1
Trait 2

• Herencia híbrida: es una mezcla de dos o más de los tipos de herencia anteriores. Dado que Scala no admite herencia múltiple con clases, la herencia híbrida tampoco es posible con clases. En Scala, podemos lograr la herencia híbrida solo a través de los rasgos.