斯卡拉 |字段覆盖

在任何面向对象的编程语言中，覆盖是一种允许子类提供其超类之一已经提供的方法或字段的特定实现的功能。在 Scala 中，与Java中的 Overriding 相比，Overriding 得到了进一步明确的说明，因为这里的方法和Fields都可以被覆盖，但它有一些必须遵守的限制。

字段覆盖规则

字段覆盖的规则如下：

• 最重要的规则之一是我们必须在子类中覆盖超类的字段时使用关键字override或 override 表示法，否则编译器将抛出错误并终止程序的执行。
  
• 为了执行字段覆盖，我们需要覆盖在超类和子类中仅使用val关键字声明的变量。
  
• 字段覆盖不能覆盖var ，因为我们既可以读取也可以写入var 。
  

现在，让我们看一些例子来说明这些限制。
例子 ：

Scala

// 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.

现在，我们可以在上面的示例中看到val在超类和子类中都使用了，因此，覆盖该字段是可行的，否则会引发错误。在这里，超类中的字段是val ，它在子类中使用override关键字覆盖。
例子 ：

斯卡拉

// 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()
     
    }
}

输出：

prog.scala:17：错误：覆盖字符串类型形状类中的值描述；
变量描述需要是一个稳定的、不可变的值
override var description:String =“这是一个圆圈。”
^
prog.scala:32：错误：覆盖字符串类型形状类中的值描述；
变量描述需要是一个稳定的、不可变的值
override var description:String =“这是一个正方形。”
^
发现两个错误

它与上面的示例相同，但是在这里发现错误，在子类中使用var来覆盖不可能的字段，因为val不能被var覆盖，如上所述。
例子 ：

斯卡拉

// 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()
     
    }
}

输出：

prog.scala:17：错误：在 Int 类型的 Animals 类中覆盖变量数；
变量号不能覆盖可变变量
覆盖 var 编号：Int = 4
^
发现一个错误

在这里， var用于覆盖上述规则中不可能的字段，因此会发现错误。