## 多个类之间的关系：继承

子类名 extends 父类名 就是 子类继承父类

继承的好处就是不劳而获

以下例子就是以喜洋洋和智羊羊中认父子而所写的代码

class Boss {
  def power(): Unit = {
    println("Boss 有权力....")
  }

  var car = "豪车"
}

class NoBody extends Boss{

}

def main(args: Array[String]): Unit = {
  val b = new NoBody()
  println(b.car)
  b.power()
}

重写：子类对父类的同名方法进行重写！

此时又要用到override了

class Boss {
  def test():Unit={}
  def power(): Unit = {
    println("Boss 有权力....")
  }

  var car = "豪车"
}

class NoBody extends Boss{
  def run():Unit= {

  }

  //    override def power(): Unit = super.power()
  override def power(): Unit = {
    println("老莫，我想吃鱼了")
  }
}

def main(args: Array[String]): Unit = {
  val b = new NoBody()
  println(b.car)
  b.power()
}

父类和子类的构造器调用顺序：

先调用父类的构造器，再调用子类的构造器

class Father() {
  println("Father 构造器被调用")
}
class Son extends Father(){
  println("Son 构造器被调用")
}

def main(args: Array[String]): Unit = {
  new Son()      
}                     结果：//Father 构造器被调用
                           //Son 构造器被调用

那么，现在写一次带参数的构造器

   子类带参构造器
        1.继承父类的属性。不用写 val,var 修饰符
   父类构造器
       直接传入参数，不用写属性的类型

class Dog(var name:String,var age:Int) {
  println(s"Dog ${name},${age} 构造器被调用")
}
class RuralDog(name:String,age:Int) extends Dog(name, age){
  println("RuralDog 的构造器...")
}

def main(args: Array[String]): Unit = {
  new RuralDog("小狗",3)
}                      结果：//Dog 小狗,3 构造器被调用
                            //RuralDog 的构造器...

相比父类，子类有新的属性将怎么写呢？

    自己的新属性，加上var，val修饰符

class Dog(var name:String,var age:Int) {
  println(s"Dog ${name},${age} 构造器被调用")
}                           "var color:String"为新加的
class RuralDog(name:String,age:Int,var color:String) extends Dog(name, age){
  println(s"RuralDog 的构造器...${color}")
}                    "${color}"为新加的

def main(args: Array[String]): Unit = {
  new RuralDog("小狗",3,"土黄色")
}                          "土黄色"为新加的

作业：

  class Point(var x: Double, var y: Double) {
    // 方法1：判断象限
    def whereAmI(): String = {
      if (x > 0 && y > 0) "第1象限"
      else if (x < 0 && y > 0) "第2象限"
      else if (x < 0 && y < 0) "第3象限"
      else if (x > 0 && y < 0) "第4象限"
      else "在坐标轴上"
    }

    // 方法2：到原点的距离
    def getDist(): Double = Math.sqrt(x * x + y * y)

    // 方法3：到另一个点的距离
    def fromPoint(other: Point): Double = {
      val dx = x - other.x
      val dy = y - other.y
      Math.sqrt(dx * dx + dy * dy)
    }

    // 方法4：重写 equals 判断是否为同一点
    override def equals(other: Any): Boolean = {
      val o = other.asInstanceOf[Point]
      o.x==x && o.y==y
    }

    def canEqual(other: Any): Boolean = other.isInstanceOf[Point]

    // 方法5：重写 toString 友好输出信息
    override def toString: String = s"${x},${y}"
  }
  class LabelPoint(val color: String, x: Double, y: Double) extends Point(x, y) {
    override def toString: String = s"${color}: ${x}, ${y}"
    println(s"LabelPoint构造器  ${color}")
  }

  def main(args: Array[String]): Unit = {
    val s1 =new Point(3.0,4.0)
    val s2 = new Point(6.0,8.0)
    println(s1.whereAmI())
    println(s1.getDist())
    println(s1.fromPoint(s2))
    println(s1==s2)
    println(s1.toString)
    val s3 =new LabelPoint("black",1.0,0)
    val s4 =new LabelPoint("black",2.0,0)
    println(s3.whereAmI())
    println(s3.getDist())
    println(s3.fromPoint(s4))
    println(s3==s4)
    println(s3.toString)
  }
}