Clases Genéricas en Scala

En Scala, formar una clase genérica es extremadamente similar a la formación de clases genéricas en Java. Las clases que toman un tipo como un parámetro se conocen como clases genéricas en Scala. Esta clase toma un tipo como un parámetro dentro de los corchetes, es decir, []. Estas clases se utilizan explícitamente para el progreso de las clases de colección en Scala. La subtipificación de tipos genéricos es invariable, es decir, si tenemos dos tipos de lista, A y B, entonces List[A] es un subtipo de List[B] si y solo si el tipo B es equivalente al tipo A.
Algunos puntos a recuerda:

• El símbolo utilizado para un parámetro de tipo de tipo simple es A , como List[A].
• Los símbolos utilizados para un parámetro de tipo de segundo, tercero, cuarto, etc. tipos en clases genéricas son, respectivamente , B, C, D, etc.
• El símbolo utilizado para una clave es A y para un valor es B en Scala Map.
• El símbolo utilizado para un valor numérico es N .

Nota: Aunque se proporcionan las convenciones de este símbolo, se puede usar cualquier símbolo para los parámetros de tipo.
analicemos algunos ejemplos a continuación.
Ejemplo:

// Scala program of forming 
// Generic classes
  
// Creating an object
object GfG
{
  
    // Main method
    def main(args: Array[String]) 
    {
  
        // Class structure for Generic
        // types 
        abstract class Divide[z] 
        {
            // Defining method 
            def divide(u: z, v: z): z
        }
  
        // Extending Generic class of 
        // type parameter Int 
        class intDivide extends Divide[Int] 
        {
            // A method returning Int 
            def divide(u: Int, v: Int): Int = u / v
        }
  
        // Extending Generic Class of 
        // type parameter Double
        class doubleDivide extends Divide[Double] 
        {
            // A method returning Double
            def divide(u : Double, v : Double) : Double = u / v
        }
  
        // Creating objects and assigning 
        // values to the methods called
        val q = new intDivide().divide(25, 5)
        val r = new doubleDivide().divide(21.0, 5.0)
  
        // Displays output 
        println(q)
        println(r)
      
    }
}

5
4.2

Aquí, la clase abstracta Divide tiene un parámetro de tipo z y está presente entre corchetes, por lo que la clase es de tipo genérico, este parámetro de tipo z puede ocupar todos y cada uno de los tipos de datos. Hemos definido un método de división dentro de la clase Genérica que tiene dos variables, es decir, u y v , y el tipo de datos de estas variables es z . La clase intDivide , como se indicó anteriormente, acepta tipos enteros y la clase doubleDivide , como se indicó anteriormente, acepta tipos dobles. Por lo tanto, el parámetro de tipo z fue reemplazado por Int y Doubletipos de datos. De esta forma, es posible la subtipificación en las clases genéricas.

Ejemplo :

// Scala program of using generic
// types for numeric values
import Numeric._
  
// Creating an object
object GfG
{
  
    // Main method
    def main(args: Array[String]) 
    {
  
        // Defining generic type for numeric
        // values with implicit parameter 
        def addition[N](a: N, b: N)(implicit num: Numeric[N]):
  
        // Using a method 'plus' 
        N = num.plus(a, b)
  
        // Displays the sum of two 
        // numbers
        println("The sum is : "+addition(88, 12))
    }
}

The sum is : 100

Aquí, vimos un parámetro de tipo genérico para valores numéricos y, por lo tanto, hemos usado el símbolo N aquí, aunque cualquier símbolo puede usarse como parámetro de tipo para tipos genéricos.