何时在Scala类中使用覆盖？

Question

这是一个令我困惑的例子。

class Point(val xc: Int, val yc: Int) { 
    var x: Int = xc 
    var y: Int = yc 
    def move(dx: Int, dy: Int) { 
     x = x + dx 
     y = y + dy 
     println ("x 的坐标点 : " + x); 
     println ("y 的坐标点 : " + y); 
    } 
} 

class Location(override val xc: Int, 
       override val yc: Int, 
       val zc: Int) extends Point(xc, yc) { 
    var z: Int = zc 

    def move(dx: Int, dy: Int, dz: Int) { 
     x = x + dx 
     y = y + dy 
     z = z + dz 
     println ("x 的坐标点 : " + x); 
     println ("y 的坐标点 : " + y); 
     println ("z 的坐标点 : " + z); 
    } 
} 

为什么方法move并不需要一个override修改？它不是类Point中的抽象方法，我认为它应该用“覆盖”来装饰。实际上，当我添加“覆盖”时，会发生错误。

而对于xc，yc，为什么“覆盖”是一个nessesary？

我真的很困惑。

我有Python的经验和很少的Java经验。

任何帮助将不胜感激，谢谢！

Answer 1

for xc, yc, why "override" is a nessesary?

不，不是必要的。在你的情况下，你在你的子类中再次使用val，这是没有必要的，因为你已经在父类中将它们定义为val。 （简单地从子类中删除VAL）

scala> class Point(val xc: Int, val yc: Int) {} 
defined class Point 

scala> class Location(xc: Int, yc: Int, val zc :Int) extends Point(xc, yc){} 
defined class Location 

Why the method "move" doesn't need an "override"?

因为你在父类move方法是不是abstract方法 或您的签名是在子类比父类不同。

例如。

abstract class Point(val xc: Int, val yc: Int) { 
    abstract def doWhatever() : Unit 
} 

class Location(xc: Int, yc: Int, val zc: Int) extends Point(xc, yc) { 
    override def doWhatever(): Unit = ??? // override is optional 
} 

你可以有醛overrid书房如果签名是一样的，所以，当你调用childClass.move()，调用重写的方法。

class Point(val xc: Int, val yc: Int) { 
    def move() = println("parent::whatever") 
} 

class Location(xc: Int, yc: Int, val zc: Int) extends Point(xc, yc) { 
    override def move() = println("child::whatever") //override is required 
} 

例如调用移动方法，

为父，

scala> val point = new Point(1, 2) 
point: Point = Point@66813e6e 

scala> point.move() 
parent::whatever 

一个孩子，

scala> val location1 = new Location(1, 2, 3) 
location1: Location = Location1@233db8e9 

scala> location1.move() 
child::whatever