继承的概念和基本语法
定义:在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。
class 子类名 extends 父类名 { 类体 }
好处:复用代码和实现多态。复用代码：子类可以继承父类的特性。
多态：子类可以在自己内部实现父类没有的特性。
语法:假设定义Parents为父类，C1为子类，通过关键字extends子类便可以继承父类的特性，相关代码为：
class C1(参数可选) extends Parents(参数可选){ }
package t2
import java.io.FileWriter
/*
6.apply 单例模式
7.伴生类 伴生对象
8.多个类
9.继承
class 子类 extends 父类
*/
object test9 {
class Aniaml(var name:String="动物") {
val age:Int=10;
def eat():Unit={
println("animal eat....")
}
def run():Unit={
println("animal run...")
}
}
class Dog() extends Aniaml(){
}
def main(args: Array[String]): Unit = {
val d1=new Dog()
d1.eat( )
d1.run()
}
}
package t2
/*
6.apply 单例模式
7.伴生类 伴生对象
8.多个类
9.继承
class 子类 extends 父类
11.子类对父类的方法的 重写
在子类中，通过override覆盖（重写）父类的同名方法
*/
object test10 {
class parent() {
def run(): Unit = {
println("run...")
}
}
class Son extends parent() {
//如果希望对父类的方法进行改进：觉得不好
def run1():Unit={}
override def run():Unit= {
println("开自动驾驶的车 run...")
}
}
def main(args: Array[String]): Unit = {
val s1=new Son()
s1.run()
}
}
继承的方法重写
当子类从父类继承的方法不能满足需要时，子类需要有自己的行为，怎么办？此时使用使用 override 可以重写父类的方法。
**super. 在子类中访问父类
package t2
/*
6.apply 单例模式
7.伴生类 伴生对象
8.多个类
9.继承
class 子类 extends 父类
11.子类对父类的方法的 重写
在子类中，通过override覆盖（重写）父类的同名方法
12.super. 在子类中访问父类
*/
object test10 {
class parent() {
val name:String=""
def run(): Unit = {
println("run...")
}
}
class Son extends parent() {
//如果希望对父类的方法进行改进：觉得不好
def run1():Unit={}
override def run():Unit= {
super.run() //super.run 在子类中调用父类的方法
println("开自动驾驶的车 run...")
}
}
def main(args: Array[String]): Unit = {
val s1=new Son()
s1.run()
}
}
继承与多态
面向对象的三个特点：_封装 继承 多态 。同一操作作用于不同的对象， 可以有不同的解释，产生不同的执行结果，这就是多态性。
通过代码来理解多态-写一个函数，它的参数类型是父类。
package t2
/*
6.apply 单例模式
7.伴生类 伴生对象
8.多个类
9.继承
class 子类 extends 父类
11.子类对父类的方法的 重写
在子类中，通过override覆盖（重写）父类的同名方法
12.super. 在子类中访问父类
*/
object test10 {
class parent() {
val name:String=""
def run(): Unit = {
println("run...")
}
}
class Son extends parent() {
//如果希望对父类的方法进行改进：觉得不好
def run1():Unit={}
override def run():Unit= {
super.run() //super.run 在子类中调用父类的方法
println("开自动驾驶的车 run...")
}
}
def main(args: Array[String]): Unit = {
val s1=new Son()
s1.run()
}
}
处理构造器的调用顺序
代码验证调用顺序：父类的主构造器->子类主构造器->子类的辅助构造器
package t2
/*
6.apply 单例模式
7.伴生类 伴生对象
8.多个类
9.继承
class 子类 extends 父类
11.子类对父类的方法的 重写
在子类中，通过override覆盖（重写）父类的同名方法
12.super. 在子类中访问父类
13.面向对象编程的三大特征：封装、继承、多态
14.构造器的调用顺序：先调用父类，再调用子类的
15.当父类，子类都存在带参数的构造器的时候，如何进行参数传递？
*/
object test12 {
//父类
class Animal(var name:String,var age:Int) {
println(s"父类的构造器被调用...${name},${age}")
def say():Unit={
println(s"Animal ${name},${age}")
}
}
//子类
class Dog(name:String,age:Int,var color:String) extends Animal(name,age){
println(s"子类的构造器被调用...${name},${age},${color}")
override def say():Unit={
super.say()
println(s"狗狗...，我的颜色是${color}")
}
}
def main(args: Array[String]): Unit = {
val d1=new Dog("旺财",1,"黑色")
d1.say()
}
}
