一. 继承的概念和基本语法
定义
在原有类的基础上定义一个新类，原有类称为父类，新类称为子类。
class 子类名 extends 父类名 { 类体 }
好处
复用代码和实现多态。复用代码：子类可以继承父类的特性。多态： 子类可以在自己内部实现父类没有的特性。
语法
假设定义Parents为父类，C1为子类，通过关键字extends子类便可以继承父类的特性，相关代码为：
class C1(参数可选) extends Parents(参数可选){ }
二. 继承的好处之复用代码
示例
代码示例
scala
体验AI代码助手
代码解读
复制代码
package level02
object base2502 {
/*
* 继承
* extends
* 好处：不劳而获
*
* */
class Animal() {
def eating(): Unit = {
println("Animal eating")
}
}
// Dog 继承了 Animal
class Dog extends Animal(){
}
def main(args: Array[String]): Unit = {
val dog1 = new Dog()
dog1.eating() // 直接可以使用父类的方法
}
}
结果展示
代码说明
- 核心概念：子类
Dog继承父类Animal - 好处：子类可以直接使用父类的方法 (
dog1.eating()) - 特点：代码复用，"不劳而获"
继承的特点
Dog就直接具备了animal的功能eating。
类图-图示
三. 继承的方法重写
格式
override def 方法名(参数可选) { }
示例
代码示例
scala
体验AI代码助手
代码解读
复制代码
package level02
object base2503 {
/*
* 继承
* 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方法!
}
}
结果展示
代码说明
- 方法重写：使用
override关键字 - super 关键字：在子类中访问父类的方法
- 完全重写，不调用父类方法
代码示例
scala
体验AI代码助手
代码解读
复制代码
package level02
object base2503 {
/*
* 继承
* extends
* 好处：不劳而获
*
* 问题：
* 如果子类觉得父类得方法并不是自己想要的，如何定义自己的方法呢？
* 1. override 重写
* 2. super 在子类内部，通过super来访问父类
* */
class Animal() {
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方法!
}
}
/*
* 继承
* extends
* 好处：不劳而获
*
* 问题：
* 如果子类觉得父类得方法并不是自己想要的，如何定义自己的方法呢？
*
*
* // Dog 继承了 Animal
class Dog extends Animal(){
// 在子类中重写（覆盖）父类的方法
override def eating():Unit = {
println("我是狗，我有自己的吃饭方式！！")
}
}
* */
结果展示
代码说明
- 方法重写：使用
override关键字 - super 关键字：在子类中访问父类的方法
- 先调用父类方法，再添加新行为
四. 继承与多态
面向对象的三个特点
面向对象的三个特点：_封装 继承 多态 。同一操作作用于不同的对象， 可以有不同的解释，产生不同的执行结果，这就是多态性。
示例
代码示例
scala
体验AI代码助手
代码解读
复制代码
package level02
object base2504 {
/*
* 面对对象的编程语言有三大特性：封装，继承，多态
*
* 多态：同一个操作，作用于不同的对象，有不同的执行结果
*
* */
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)
}
}
结果展示
代码说明
-
多态表现：同一个
test函数，传入不同子类对象产生不同行为 -
运行结果：
test(cat)→ "我是猫，我吃饭小口小口吃"test(dog)→ "我是狗，我吃饭大口大口嚼"
-
核心思想：父类引用指向子类对象，调用方法时执行子类的实现
五. 处理构造器的调用顺序
示例
代码示例
scala
体验AI代码助手
代码解读
复制代码
package level02
object base2505 {
/*
* 存在继承关系的时候，构造器的调用顺序？
* 父类构造器 → 子类构造器
*
* */
class Animal() {
println("父类构造器被调用......")
}
// Dog 继承了 Animal
class Dog extends Animal() {
println("子类：Dog 构造器被调用......")
}
// Puppy 继承了 Dog
class Puppy extends Dog() {
println("子类：Puppy 构造器被调用......")
}
def main(args: Array[String]): Unit = {
new Puppy(); // new会自动调用构造器去生成对象
}
}
结果展示
代码说明
- 构造器调用顺序：父类 → 子类（逐级向上）
- 继承链：
Animal→Dog→Puppy
六. 带参构造器的写法
要点
-
父类构造器正常写。
-
在写子类构造器时：
- 如果某个属性可以从父类中继承过来，那么这些属性就不要添加任何的修饰符(val,var都不加)如果这属性是子类自己特有的，就需要补充修饰符；
- 在父类构造器时，直接传入对应的参数。
示例
代码示例
scala
体验AI代码助手
代码解读
复制代码
package level02
object base2506 {
// 父类: name, age
class Animal(val name: String, var age: Int) {
println(s"父类构造器 ..... ${name} ${age}")
def eat(): Unit = {
println(s"${name} ${age} eating....")
}
}
// 子类: name,age,color
class Dog(name: String, age: Int, var color: String) extends Animal(name, age) {
println(s"子类构造器 ..... ${name} ${age} ${color}")
}
def main(args: Array[String]): Unit = {
val dog1 = new Dog("旺财", 1, "黑色")
dog1.eat()
}
}
