继承
概念：
在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。
语法：
class 子类名 extends 父类名 { 类体 }
作用：
复用代码和实现多态。
- 多态：子类可以在自己内部实现父类没有的特性。
语法:
假设定义Parents为父类，C1为子类，通过关键字extends子类便可以继承父类的特性，相关代码为：
class C1(参数可选) extends Parents(参数可选){ }
🎈复用代码
复用代码：子类可以继承父类的特性。
示例代码：
package TestExtends
class Animal(){
var legs = 4
def eating(): Unit = {
println("Animal eating")
}
}
class Dog extends Animal(){
}
object Main {
def main(args: Array[String]): Unit = {
var d1 = new Dog()
println(d1.legs)
d1.eating() // 子类的对象，调用父类的方法
}
}
继承的特点：Dog就直接具备了animal的功能eating。
🎫继承的方法重写
使用 override 可以进行重写父类的方法
格式：
override def 方法名(参数可选) { }
示例代码：
package Luwenzhen
object class07 {
/*
继承
extends
问题：
如果子类觉得父类的方法并不是自己要的，如何定义自己的方法
*/
class Animal() {
def eating():Unit={
println("Animal eating")
}
}
//Dog继承了Animal
class Dog extends Animal(){
//在子类中重写（覆盖）父类的方法
override def eating(): Unit = {
println("我是小珍，我最爱玩游戏！")
}
}
def main(args: Array[String]): Unit = {
val dog1=new Dog()
dog1.eating()//可以自己的eating的方法
}
}
🎗️Super关键字
在子类的内部，通过super来访问父类
示例代码：
package Luwenzhen
object class07 {
/*
继承
extends
问题：
如果子类觉得父类的方法并不是自己要的，如何定义自己的方法
1.override 重写
2.super 在子类的内部，通过super来访问父类
*/
class Animal() {
def run():Unit={
}
def eating():Unit={
println("Animal eating")
}
}
//Dog继承了Animal
class Dog extends Animal(){
//在子类中重写（覆盖）父类的方法
override def eating(): Unit = {
//调用父类的方法
//在子类的内部，通过super来访问父类
super.eating()
println("我是小珍，我最爱玩游戏！")
}
}
def main(args: Array[String]): Unit = {
val dog1=new Dog()
dog1.eating()//可以自己的eating的方法
}
}
🎡多态
面向对象的三个特点：
- 封装
- 继承
- 多态
概念：
同一个操作，作用于不同的对象，有不同的执行结果，这就是多态性
示例代码：
package Luwenzhen
object class08 {
/*
面向对象的编程语言三大特性：封装，继承，多态
多态：同一个操作，作用于不同的对象，有不同的执行结果
*/
class Animal() {
def eating():Unit={
println("Animal eating")
}
}
//Dog继承了Animal
class Dog extends Animal(){
//在子类中重写（覆盖）父类的方法
override def eating(): Unit = {
println("我是狗，大口嚼着吃饭！")
}
}
//Cat 继承了Animal
class Cat extends Animal(){
//在子类中重写（覆盖）父类的方法
override def eating(): Unit = {
println("我是猫，小口嚼着吃饭！")
}
}
//测试函数
//它的参数类型是父类
def test(animal:Animal):Unit={
animal.eating()
}
def main(args: Array[String]): Unit = {
val cat =new Cat()
val dog =new Dog()
//传入子类的对象
test(cat)
test(dog)
}
}
🎆处理构造器的调用顺序
调用顺序：
父类的主构造器->子类主构造器->子类的辅助构造器
代码示例：
package Luwenzhen
object class09 {
/*
存在继承关系的时候，构造器的调用顺序
父类构造器 → 子类构造器
*/
class Animal() {
println("1.父类构造器被调用。。。")
}
//Dog继承了Animal
class Dog extends Animal(){
println("2.子类：Dog 构造器被调用。。。")
}
//Puppy继承了Dog
class Puppy extends Dog(){
println("3.子类：Puppy 构造器被调用。。。")
}
def main(args: Array[String]): Unit = {
new Puppy();//new会自动调用构造器去生成对象
}
}
