Sobrecarga de métodos en Scala

La sobrecarga de métodos es la forma común de implementar polimorfismos . Es la capacidad de redefinir una función en más de una forma. Un usuario puede implementar la sobrecarga de funciones definiendo dos o más funciones en una clase que comparten el mismo nombre. Scala puede distinguir los métodos con diferentes firmas de métodos. es decir, los métodos pueden tener el mismo nombre pero con una lista de parámetros diferente (es decir, el número de parámetros, el orden de los parámetros y los tipos de datos de los parámetros) dentro de la misma clase.

• Los métodos sobrecargados se diferencian según el número y el tipo de los parámetros pasados ​​como argumento a los métodos.
• No podemos definir más de un método con el mismo nombre, Orden y el tipo de los argumentos. Sería un error del compilador.
• El compilador no considera el tipo de retorno al diferenciar el método sobrecargado. Pero no puede declarar dos métodos con la misma firma y diferente tipo de retorno. Lanzará un error en tiempo de compilación.

¿Por qué necesitamos la sobrecarga de métodos?

Si necesitamos hacer el mismo tipo de operación de diferentes maneras, es decir, para diferentes entradas. En el ejemplo que se describe a continuación, estamos realizando la operación de suma para diferentes entradas. Es difícil encontrar muchos nombres significativos diferentes para una sola acción.

Diferentes formas de hacer métodos de sobrecarga.

La sobrecarga de métodos se puede hacer cambiando:

• El número de parámetros en dos métodos.
• Los tipos de datos de los parámetros de los métodos.
• El Orden de los parámetros de los métodos.

Cambiando el número de parámetros.

Ejemplo:

// Scala program to demonstrate the function 
// overloading by changing the number 
// of parameters 
class GFG
{
      
    // function 1 with two parameters
    def fun(p:Int, q:Int)
    {
        var Sum = p + q;
        println("Sum in function 1 is:" + Sum);
    }
      
    // function 2 with three parameters
    def fun(p:Int, q:Int, r:Int)
    {
        var Sum = p + q + r;
        println("Sum in function 2 is:" + Sum);
    }
}
object Main 
{
    // Main function
    def main(args: Array[String]) 
    {
          
    // Creating object of GFG class
    var obj = new GFG();
    obj.fun(6, 8);
    obj.fun(5, 10, 58);
    }
}

Producción:

Sum in function 1 is:14
Sum in function 2 is:73

Al cambiar los tipos de datos de los parámetros

Ejemplo:

// Scala program to demonstrate the function 
// overloading by changing the data types 
// of the parameters 
class GFG
{
      
    // Adding three integer elements
    def fun(p:Int, q:Int, r:Int)
    {
        var Sum = p + q + r;
        println("Sum in function 1 is:"+Sum);
    }
      
    // Adding three double elements
    def fun(p:Double, q:Double, r:Double)
    {
        var Sum = p + q + r;
        println("Sum in function 2 is:"+Sum);
    }
}
object Main 
{
    // Main method
    def main(args: Array[String]) 
    {
          
    // Creating object of GFG class
    var obj = new GFG();
    obj.fun(6, 8, 10);
    obj.fun(5.9, 10.01, 58.7);
    }
}

Producción:

Sum in function 1 is:24
Sum in function 2 is:74.61

Cambiando el Orden de los parámetros

Ejemplo:

// Scala program to demonstrate the function 
// overloading by changing the 
// order of the parameters 
class GFG
{
      
    // Function 1
    def fun(name:String, No:Int)
    {
        println("Name of the watch company is:" + name);
        println("Total number of watch :" + No);
    }
      
    // Function 2
    def fun(No:Int, name:String )
    {
        println("Name of the watch company is:" + name);
        println("Total number of watch :" + No);
    }
}
object Main 
{
    // Main Function
    def main(args: Array[String])
    {
          
    // Creating object of GFG class
    var obj = new GFG();
    obj.fun("Rolex", 10);
    obj.fun("Omega", 10);
    }
}

Producción:

Name of the watch company is:Rolex
Total number of watch :10
Name of the watch company is:Omega
Total number of watch :10

¿Qué sucede cuando la firma del método es la misma y el tipo de devolución es diferente?

El compilador dará un error ya que el valor devuelto por sí solo no es suficiente para que el compilador descubra qué función tiene que llamar. Solo si ambos métodos tienen diferentes tipos de parámetros (por lo tanto, tienen una firma diferente), entonces es posible la sobrecarga de métodos.
Ejemplo:

// Example to show error when method signature is same  
// and return type is different. 
object Main {
           
        // Main method
        def main(args: Array[String]) {
     println("Sum in function 1 is:" + fun(6, 8) );
     println("Sum in function 2 is:" + fun(6, 8) );
    }
      
     // function 1 
    def fun(p:Int, q:Int) : Int = {
        var Sum: Int = p + q;
        return Sum;
         
    }
      
 // function 2 
    def fun(p:Int, q:Int) : Double = {
        var Sum: Double = p + q + 3.7;
        return Sum;
    }
     
      
  
}

Error de tiempo de compilación:

prog.scala:10: error: referencia ambigua a definición sobrecargada,
ambos método fun en objeto Main de tipo (p: Int, q: Int)Double
y método fun en objeto Main de tipo (p: Int, q: Int)Int hacer
coincidir los tipos de argumentos (Int,Int) y el tipo de resultado esperado Any
println(“La suma en la función 1 es:” + fun(6, 8));
^
prog.scala:11: error: referencia ambigua a definición sobrecargada,
ambos métodos divertidos en el objeto Principal de tipo (p: Int, q: Int) Doble
y método divertido en el objeto Principal de tipo (p: Int, q: Int) Int
coincide con los tipos de argumentos (Int,Int) y el tipo de resultado esperado Any
println(“La suma en la función 2 es:” + fun(6, 8));
^
prog.scala:22: error: el método fun se define dos veces
los símbolos en conflicto se originaron en el archivo ‘prog.scala’
def fun(p:Int, q:Int) : Double = {
^
tres errores encontrados