Anulación de métodos en Scala

La anulación de métodos en Scala es idéntica a la anulación de métodos en Java , pero en Scala, las funciones de anulación se elaboran más, ya que aquí se pueden anular ambos métodos, así como var o val . Si una subclase tiene el nombre del método idéntico al nombre del método definido en la clase principal, entonces se sabe que está anulando el método , es decir, las subclases que son heredadas por la superclase declarada anulan el método definido en la superclase utilizando el anular palabra clave.

Veamos el diagrama de flujo de la anulación del método para visualizarlo explícitamente.

Aquí, en el diagrama mencionado anteriormente , School es la superclase que tiene un método definido que se denomina NumberOfStudents() y este método es anulado por las subclases, es decir, clase 1, clase 2, clase 3. entonces, todas las subclases tienen el mismo método con nombre definido en la superclase.

cuando una subclase desea impartir una implementación particular para el método definido en la clase principal, esa subclase anula el método definido de la clase principal. Cuando deseamos reconstruir el método definido en la superclase, podemos aplicar la anulación del método.
Veamos un ejemplo que está relacionado con el diagrama mencionado anteriormente de la anulación del método.

Ejemplo :

// Scala program of method overriding
  
// Creating a super class
class School
{ 
  
    // Method defined
    def NumberOfStudents()=
    { 
        0 // Utilized for returning an Integer
    } 
} 
  
// Creating a subclass 
class class_1 extends School
{
      
    // Using Override keyword
    override def NumberOfStudents()=
    { 
        30
    } 
} 
  
// Creating a subclass 
class class_2 extends School
{ 
  
    // Using override keyword 
    override def NumberOfStudents()=
    { 
        32
    } 
} 
  
// Creating a subclass
class class_3 extends School
{ 
      
    // Using override keyword
    override def NumberOfStudents()=
    { 
        29
    } 
} 
  
// Creating object 
object GfG
{ 
  
    // Main method
    def main(args:Array[String])
    { 
          
        // Creating instances of all
        // the sub-classes
        var x=new class_1() 
        var y=new class_2() 
        var z=new class_3()
          
        // Displays number of students in class_1
        println("Number of students in class 1 : " + 
                                x.NumberOfStudents()) 
          
        // Displays number of students in class_2
        println("Number of students in class 2 : " + 
                                y.NumberOfStudents())
          
        // Displays number of students in class_3
        println("Number of students in class 3 : " +
                                z.NumberOfStudents()) 
          
    } 
} 

Number of students in class 1 : 30
Number of students in class 2 : 32
Number of students in class 3 : 29

En el ejemplo anterior, tenemos una clase llamada Escuela que define un método NúmeroDeEstudiantes() y tenemos tres clases, es decir, clase_1, clase_2 y clase_3 que heredan de la superclase Escuela y estas subclases anulan el método definido en la superclase . -clase.

Ejemplo :

// Scala program of method overriding
  
// Creating a super class
class Shapes
{ 
  
    // Method defined with parameters
    def Area(l:Double, b:Double, r:Double)=
    { 
      
        0.0 // Utilized for returning double
    } 
} 
  
// Creating a subclass 
class Rectangle extends Shapes
{
      
    // Overriding method to find
    // area of the rectangle 
    override def Area(l:Double, b:Double, r:Double)=
    { 
      
        (l * b)
    } 
} 
  
// Creating a subclass 
class Circle extends Shapes
{ 
  
    // Overriding method to find
    // area of the circle
    override def Area(l:Double, b:Double, r:Double)=
    { 
          
        ((3.14)* r * r)
    } 
} 
  
// Creating object 
object GfG
{ 
  
    // Main method
    def main(args:Array[String])
    { 
          
        // Creating instances of all
        // the sub-classes
        var rectangle = new Rectangle() 
        var circle = new Circle() 
          
        // Displays area of the rectangle
        println(rectangle.Area(3, 11, 4)) 
          
        // Displays area of the circle
        println(circle.Area(1, 7, 10)) 
          
    } 
} 

33.0
314.0

En el ejemplo anterior, Area es un método de la superclase que debe ser anulado por los métodos definidos en las subclases. Aquí, estamos encontrando el área pero para diferentes formas usando el mismo nombre de método, es decir, Área , por lo tanto, podemos decir que esta anulación de método se puede aplicar para el mismo tipo de operaciones pero para diferentes categorías y vale la pena señalar que los métodos deben tener mismos tipos de datos y la misma cantidad de parámetros que se definen en la superclase; de ​​lo contrario, el compilador arrojará un error. Aunque el orden de los parámetros en el método definido se puede modificar en las subclases cuando se anula el método.

Hay algunas restricciones que debemos seguir para la anulación de métodos, estas son las siguientes:

• Para la anulación de métodos, una de las reglas cruciales es que la clase que está anulando debe utilizar la anulación del modificador o la anotación de anulación.
• Los constructores auxiliares no pueden llamar inmediatamente a los constructores de la superclase. Difícilmente pueden llamar a los constructores primarios que, a la inversa, llamarán al constructor de la superclase.
• En Method Overriding, no podremos anular un var con un def o val, de lo contrario arroja un error.
• Aquí, no podremos anular un val en la superclase por una var o def en la subclase, y si la var en la superclase es abstracta, podemos anularla en la subclase.
• Si un campo se establece como var , entonces puede anular la definición que se define en la superclase. La var solo puede anular una combinación getter o setter en la superclase.

Nota:

1. Los constructores auxiliares se definen como métodos que utilizan las palabras clave def y this , donde este es el nombre del constructor.
2. Los constructores primarios comienzan desde el principio de la definición de la clase y se extienden por todo el cuerpo de la clase.

Veamos algunos ejemplos ahora.

Ejemplo :

// Scala program of method 
// Overriding
  
// Creating a class
class Animal
{
      
    // Defining a method
    def number()
    { 
        println("We have two animals")
  
    } 
} 
  
// Extending the class Animal
class Dog extends Animal
{
  
    // using override keyword
    override def number()
    { 
          
        // Displays output
        println("We have two dogs") 
  
    } 
} 
  
// Creating object 
object GfG
{ 
  
    // Main method
    def main(args:Array[String])
    { 
          
        // Creating object of the subclass
        // Dog
        var x = new Dog() 
              
        // Calling overridden method
        x.number() 
              
    } 
} 

We have two dogs

Aquí, hemos anulado el método utilizando la anulación de palabras clave . En el ejemplo anterior, la superclase Animal tiene un método llamado número que se anula en la subclase Perro . Por lo tanto, se puede llamar al método anulado creando el objeto de la subclase.

Ejemplo :

// Scala program of method 
// overriding
  
// Creating super-class
class Students(var rank:Int, var name:String)
{
      
    // overriding a method 'toString()'
    override def toString():String =
    {
        " The rank of "+name+" is : "+rank
    }
}
  
// Creating a subclass of Students
class newStudents(rank:Int, name:String)
        extends Students(rank, name){
}
  
// Inheriting main method of 
// the trait 'App' 
object GfG extends App
{
      
    // Creating object of the super-class
    val students = new Students(1, "Geeta Sharma")
      
    // Displays output
    println(students)
      
    // Creating object of the subclass
    val newstudents = new newStudents(3, "Priti Singh")
      
    // Displays output
    println(newstudents)
  
}

The rank of Geeta Sharma is : 1
The rank of Priti Singh is : 3

Aquí, el constructor de la superclase, es decir, Students , se llama desde el constructor principal de la subclase, es decir, newStudents , por lo que el constructor de la superclase se llama utilizando la palabra clave extends .
Nota: La clase AnyRef tiene un método toString() definido y, como sabemos, cada clase es una subclase de la clase AnyRef , por lo que el método toString() se anula con la palabra clave override .

• En Scala, la sobrecarga de métodos nos proporciona una propiedad que nos permite definir métodos con el mismo nombre pero que tienen diferentes parámetros o tipos de datos, mientras que la anulación de métodos nos permite redefinir el cuerpo del método de la superclase en la subclase del mismo nombre y los mismos parámetros. o tipos de datos para alterar el rendimiento del método.
• En Scala, la sobreescritura de métodos usa el modificador de sobreescritura para sobreescribir un método definido en la superclase, mientras que la sobrecarga de métodos no requiere ninguna palabra clave o modificador, solo necesitamos cambiar el orden de los parámetros usados ​​o el número de parámetros de el método o los tipos de datos de los parámetros para la sobrecarga del método.

Para redefinir un solo método de diferentes maneras, podemos anular el método, lo que nos ayuda a realizar diferentes operaciones con el mismo nombre de método. Como en el diagrama que se muestra arriba, tiene una escuela de superclase que tiene un método llamado NumberOfStudents() que es anulado por las subclases para realizar diferentes acciones.