Escala | Anulación de campo

En cualquier lenguaje de programación orientado a objetos, Overriding es una función que permite que una subclase proporcione una implementación específica de un método o campo que ya proporciona una de sus superclases. En Scala, Overriding se establece explícitamente en comparación con Overriding en Java, ya que aquí se pueden anular  tanto los métodos como los campos , pero tiene algunas restricciones que es obligatorio seguir.
 

Las reglas para la anulación de campos son las siguientes: 
 

• La regla más importante es que debemos utilizar la palabra clave anular o anular la notación al anular los campos de la superclase en las subclases; de lo contrario, el compilador arrojará un error y finalizará la ejecución del programa. 
   
• Para ejecutar una anulación de campo , necesitamos anular las variables que se declaran utilizando solo la palabra clave val tanto en la superclase como en las subclases. 
   
• La anulación de campos no puede anular var , porque podemos leer y escribir var . 
   

Ahora, veamos algunos ejemplos para ilustrar estas restricciones.
Ejemplo : 
 

// Scala program of Field
// Overriding
 
// Creating class
class Shapes
{
 
    // Creating a variable with
    // val keyword
    val description:String = "shape"
}
 
// Creating a subclass
class shape_1 extends Shapes
{
 
    // Overriding field using
    // 'override' keyword
    override val description:String ="It is a circle."
 
    // Defining a method
    def display()
    {
     
        // Displays output
        println(description)
    }
}
 
// Creating a subclass
class shape_2 extends Shapes
{
 
    // overriding field using
    // 'override' keyword
    override val description:String ="It is a square."
 
    // Defining a method
    def display()
    {
     
        // Displays output
        println(description)
    }
}
 
// Creating object
object GfG
{
 
    // Main method
    def main(args:Array[String])
    {
     
        // Creating instances for all
        // the sub-classes
        var x = new shape_1()
        var y = new shape_2()
     
        // Calling methods
        x.display()
        y.display()
     
    }
}

It is a circle.
It is a square.

Ahora, podemos ver en el ejemplo anterior que val se utiliza tanto en la superclase como en la subclase, por lo que la anulación del campo era practicable; de ​​lo contrario, habría arrojado un error. Aquí, el campo de la superclase es val , que se reemplaza en las subclases mediante la palabra clave override .
Ejemplo : 
 

// Scala program of Field
// Overriding
 
// Creating class
class Shapes
{
 
    // Creating a variable with
    // val keyword
    val description:String = "shape"
}
 
// Creating a subclass
class shape_1 extends Shapes
{
 
    // Overriding field using
    // 'override' keyword
    override var description:String ="It is a circle."
     
    // Defining a method
    def display()
    {
     
        // Displays output
        println(description)
    }
}
 
// Creating a subclass
class shape_2 extends Shapes
{
 
    // overriding field using
    // 'override' keyword
    override var description:String ="It is a square."
 
    // Defining a method
    def display()
    {
     
        // Displays output
        println(description)
    }
}
 
// Creating object
object GfG
{
 
    // Main method
    def main(args:Array[String])
    {
     
        // Creating instances for all
        // the sub-classes
        var x = new shape_1()
        var y = new shape_2()
     
        // Calling methods
        x.display()
        y.display()
     
    }
}

Es el mismo ejemplo que el anterior, pero aquí se encuentran errores como aquí, var se usa en las subclases para anular los campos que no es posible ya que val no puede ser anulado por var como se indicó anteriormente.
Ejemplo : 
 

// Scala program of Field
// Overriding
 
// Creating class
class Animals
{
 
    // Creating a variable with
    // 'var' keyword
    var number:Int = 2
}
 
// Creating a subclass
class Cat extends Animals
{
 
    // Overriding field using
    // 'override' keyword
    override var number:Int = 4
     
    // Defining a method
    def show()
    {
     
        // Displays output
        println("We have " + number + " cats.")
    }
}
 
// Creating object
object GfG
{
 
    // Main method
    def main(args:Array[String])
    {
     
        // Creating instance of the
        // sub-class
        var cat = new Cat()
     
        // Calling method
        cat.show()
     
    }
}

Aquí, var se utiliza para anular campos, lo que no es posible según lo establecido en las reglas anteriores, por lo que se encuentra un error.