大数据实时处理 1.7 掌握Scala类、对象、抽象类与特质

package net.lym.day04

/**
 * 功能：用户类
 * 作者：柠檬
 * 日期：2023年03月27日
 */


class User {
  private  var name = "张三丰"
  private var gender = "男"
  private var age = 25
  def speak(): Unit = println("我叫" + name + " , " + gender + " , 今年" + age + "岁了~")

}

说明：在Scala里，如果一个类不写访问修饰符，那么默认访问级别为public，这与Java是不一样的。

（二）类的实例化

关键字new用于创建类的实例
实例化User类，调用其speak()方法
在day04包里创建TestUser对象

package net.lym.day04
/**
 * 功能：测试用户类
 * 作者：柠檬
 * 日期：2023年03月27日
 */
object TestUser {
  def main(args: Array[String]): Unit = {
    // 创建用户对象
    val user = new User() // ()可以省掉，调用的是无参构造方法来实列化
    // 调用对象方法
    user.speak()
  }

}

运行程序，查看结果

访问私有属性name，系统会报错

怎么才能访问类的私有属性呢？后面我们会定义setter和getter来访问私有属性。

二、单例对象

（一）单例对象概念

Scala中没有静态方法或静态字段，但是可以使用关键字object定义一个单例对象，单例对象中的方法相当于Java中的静态方法，可以直接使用“单例对象名.方法名”方式进行调用。单例对象除了没有构造器参数外，可以拥有类的所有特性。

（二）案例演示

在day04里创建Person单例对象，包含三个私有属性和一个公共方法

package net.lym.day04
/**
 * 功能：单例对象1Person
 * 作者：柠檬
 * 日期：2023年03月27日
 */
object Person {
  private  var name = "张三丰"
  private var gender = "男"
  private var age = 25
  def speak(): Unit = println("我叫" + name + " , " + gender + " , 今年" + age + "岁了~")

}

在day04包里创建TestPerson对象

package net.lym.day04
/**
 * 功能：测试单例对象1Person
 * 作者：柠檬
 * 日期：2023年03月27日
 */
object TestPerson {
  def main(args: Array[String]): Unit = {
    Person.speak()
  }

}

运行程序，查看结果

三、伴生对象

（一）伴生对象概念

当单例对象的名称与某个类的名称一样时，该对象被称为这个类的伴生对象。类被称为该对象的伴生类。类和它的伴生对象必须定义在同一个文件中，且两者可以互相访问其私有成员。

（二）案例演示

在net.lym.day04包里，创建Scala类Student，在文件里创建其伴生对象Student

package net.lym.day04
/**
 * 功能：演示半生对象
 * 作者：柠檬
 * 日期：2023年03月27日
 */
// 伴生类
class Student {
  private var name = "陈燕文"

  def speak(): Unit = {
    // 访问伴生对象的私有成员 （Student.age)
    println("我叫" + name + "， 今年" + Student.age + "岁了~")
  }

}
// 伴生对象
object Student{
  private var age = 18

  def main(args: Array[String]): Unit = {
    // 基于伴生类创建学生对象
    val student = new Student()
    // 访问伴生对象的私有成员（name)
    println("姓名：" + student.name)
    // 访问伴生对象的私有成员（age)
    println("年龄：" + age)
    // 调用伴生类对象的方法
    student.speak()

  }
}

对应关系图

运行程序，查看结果

四、get和set方法

（一）生成原则

Scala默认会根据类的属性的修饰符生成不同的get和set方法

1、val修饰的属性 - 公共常量属性

系统会自动生成一个私有常量属性和一个公有get方法。

2、var修饰的属性 - 公共变量属性

系统会自动生成一个私有变量属性和一对公有get/set方法。

3、private var修饰的属性 - 私有变量属性

系统会自动生成一对私有get/set方法，相当于类的私有属性，只能在类的内部和伴生对象中使用。

4、private[this]修饰的属性 - 本地私有变量属性

系统不会生成get/set方法，即只能在类的内部使用该属性。

（二）案例演示

任务1、利用系统自动生成的get和set方法

（1）创建Dog类

在net.lym.day04包里创建Dog类

package net.lym.day04
/**
 * 功能：狗类
 * 作者：柠檬
 * 日期：2023年03月27日
 */
class Dog {
  val id: Int = 1 //  系统会自动生成公共的get 方法， 不会生成set方法
  var name: String = "瑞瑞"  // 系统会自动生成公共的get 方法和set方法
  private var gender:String = "公"  // 系统会生成私有的get和set方法，只有伴生对象可以访问
  private [this] var age: Int = 5 // 系统不会生成get和set方法，即使伴生对象也无法访问

}

（2）编译成字节码文件

在项目的out目录里，逐层点开，找到Dog，那就是生成字节码文件

直接用记事本打开就是乱码

（3）将字节码文件反编译为Java代码

Java反编译工具 - Java Decompiler

使用Java反编译工具将字节码文件反编译为Java代码

package net.lym.day04;

import scala.reflect.ScalaSignature;

@ScalaSignature(bytes = "\006\005}2Aa\003\007\001'!)!\004\001C\0017!9a\004\001b\001\n\003y\002BB\022\001A\003%\001\005C\004%\001\001\007I\021A\023\t\017E\002\001\031!C\001e!1\001\b\001Q!\n\031Bq!\017\001A\002\023%Q\005C\004;\001\001\007I\021B\036\t\ru\002\001\025)\003'\021\031q\004\001)Q\005A\t\031Ai\\4\013\0055q\021!\0023bsB\"$BA\b\021\003\ra\0270\034\006\002#\005\031a.\032;\004\001M\021\001\001\006\t\003+ai\021A\006\006\002/\005)1oY1mC&\021\021D\006\002\007\003:L(+\0324\002\rqJg.\033;?)\005a\002CA\017\001\033\005a\021AA5e+\005\001\003CA\013\"\023\t\021cCA\002J]R\f1!\0333!\003\021q\027-\\3\026\003\031\002\"a\n\030\017\005!b\003CA\025\027\033\005Q#BA\026\023\003\031a$o\\8u}%\021QFF\001\007!J,G-\0324\n\005=\002$AB*ue&twM\003\002.-\005Aa.Y7f?\022*\027\017\006\0024mA\021Q\003N\005\003kY\021A!\0268ji\"9q'BA\001\002\0041\023a\001=%c\005)a.Y7fA\0051q-\0328eKJ\f!bZ3oI\026\024x\fJ3r)\t\031D\bC\0048\021\005\005\t\031\001\024\002\017\035,g\016Z3sA\005\031\021mZ3")
public class Dog {
  private final int id = 1;
  
  public int id() {
    return this.id;
  }
  
  private String name = "瑞瑞";
  
  public String name() {
    return this.name;
  }
  
  public void name_$eq(String x$1) {
    this.name = x$1;
  }
  
  private String gender = "公";
  
  private String gender() {
    return this.gender;
  }
  
  private void gender_$eq(String x$1) {
    this.gender = x$1;
  }
  
  private int age = 5;
}

（4）说明反编译生成的Java代码

使用name属性举例，在Scala中，get和set方法并非被命名为getName和setName，而是被命名为name和name_=，由于JVM不允许在方法名中出现=，因此=被翻译成$eq。
从上述代码可以看出，由于属性id使用val修饰，因此不可修改，只生成了与get方法对应的id()；属性name使用var修饰，因此生成了与get和set方法对应的name()和name_$eq()方法，且都为public；属性gender由于使用private var修饰，因此生成了private修饰的get和set方法 - gender()和gender_$eq()；属性age由于使用private[this]修饰，因此没有生成get和set方法，只能在类的内部使用。

（5）创建单例对象用来测试Dog类

创建TestDog单例对象

package net.lym.day04

/**
 * 功能：测试狗类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
object TestDog {
  def main(args: Array[String]): Unit = {
    // 创建狗对象
    val dog: Dog = new Dog()
    // 访问id属性
    println("id: " + dog.id)
    // 设置name属性
    dog.name = "欢欢"
    // 访问name属性
    println("name: " + dog.name)
  }
}

运行程序，查看结果

注意：本地私有属性age，不能访问，即使伴生对象也无法访问

私有属性gender只有在伴生对象里可以访问，在非伴生对象TestDog里是无法访问的

创建Dog类的伴生对象，可以访问属性id和name，就可以访问Dog类的私有属性gender

package net.lym.day04

/**
 * 功能：狗类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Dog {
  val id: Int = 1 // 系统会自动生成公共的get方法
  var name: String = "瑞瑞" // 系统会自动生成公共的get和set方法
  private var gender: String = "公" // 系统会自动生成私有的get和set方法，只有伴生对象可以访问
  private[this] var age: Int = 5 // 系统不会生成get和set方法，即使伴生对象也无法访问
}

// 伴生对象
object Dog {
  def main(args: Array[String]): Unit = {
    // 创建Dog对象
    val dog: Dog = new Dog()
    // 伴生对象访问id属性
    println("id: " + dog.id)
    // 伴生对象访问name属性
    dog.name = "萌萌哒"
    println("name: " + dog.name)
    // 伴生对象设置伴生类对象的私有属性gender
    dog.gender = "母"
    // 伴生对象访问伴生类对象的私有属性gender
    println("gender: " + dog.gender)
  }
}

运行程序，查看结果

即使伴生对象也无法访问伴生类的本地私有属性age

类似的效果，用Java来实现

任务2、用户自己编写私有属性的Scala风格的get和set方法

注意：set方法的写法 —— 方法名_=
在net.lym.day04包里创建Cat类

package net.lym.day04
/**
 * 功能：猫类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
//伴生类
class Cat {
  private var catName: String = "虎丸"

  // 定义get方法  -name
  def  name: String = catName  // 相当于Java里的getCatName方法

  // 定义set方法  -name_=
  def  name_=(name: String): Unit = { //相当于Java里的setCatName方法
    catName = name
  }

}
// 伴生对象
object Cat{
  def main(args: Array[String]): Unit = {
    // 创建猫对象
    val cat : Cat = new Cat()
    // 获取对象属性(通过get方法访问私有属性)
    println("猫原来的名字： " + cat.name) // 直接访问私有属性： cat.catName
    //  设置对象属性(通过set方法访问私有属性)
    cat.name_=("冰轮丸") // 直接访问私有属性： cat.catName = "冰轮丸"
    // 访问伴生对象私有属性
    println("猫现在的名字： " + cat.catName)
  }

}

运行程序，查看结果

任务3、用户自己编写私有属性的Java风格的get和set方法

注意：get方法 —— getXXX()，set方法——setXXX()
在net.lym.day04包里创建Bird类

package net.lym.day04
/**
 * 功能：鸟类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Bird {
  private var name = "玲玲"

  // Java风格的get方法
  def  getName: String = name

  // Java风格的set方法
  def setName(name: String): Unit = {
    this.name = name
  }

}
// 伴生对象
object  Bird{
  def main(args: Array[String]): Unit = {
    // 创建鸟对象
    val bird = new Bird()
    // 获取对象属性（通过get方法访问私有属性）
    println("鸟原来的名字： " + bird.getName)
    //  设置对象属性(通过set方法访问私有属性)
    bird.name_=("菲菲") // 直接访问私有属性： bird.name = "菲菲"
    // 访问伴生对象私有属性
    println("鸟现在的名字： " + bird.name)
  }
}

运行程序，查看结果

五、构造器

Scala中的构造器分为主构造器和辅助构造器。

（一）主构造器

1、构造器参数带val或var

主构造器的参数直接放在类名之后，且将被编译为类的成员变量，其值在初始化类时传入。注意，构造器参数必须指定类型
在net.lym.day05包里创建Person类

package net.lym.day05
/**
 * 功能：人类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Person(val name: String, var age: Int = 18) {
  def speak(): Unit = println("我叫" + name + "今年" + age + "岁了~")


}
// 伴生对象
object Person{
  def main(args: Array[String]): Unit = {
    // 基于主构造器创建对象，传入两个参数值
    val person = new Person("李文华", age = 25)

    // 访问构造器参数，其实是访问成员属性
    println("姓名：" + person.name)
    println("年龄：" + person.age)

    // 调用对象方法
    person.speak()

    // 修改对象属性（name 属性不能改，age 属性可以改）
    person.age_=(26)

    // 再次调用对象的方法
    person.speak()
  }

}

运行程序，查看结果

修改对象的name属性，要报错，因为主构造器的name参数是常量，所以类不提供设置属性的方法

因为主构造器第二个参数是有初始值，所以创建对象时可以不再初始化第二个参数，采用主构造器参数的初始值

2、构造器参数带访问权限

可以通过对主构造器的参数添加访问修饰符来控制参数的访问权限
创建Person类，将参数age设置为私有的，参数name设置为不可修改（val）

class Person (val name: String, private var age: Int) {
}

系统会为name属性添加一个公共的get方法
系统会为age属性添加一个私有的get和set方法

3、构造器参数不带var或val

构造参数也可以不带val或var，此时默认为private[this] val，这样会被编译成类的本地私有成员，不会生成get和set方法，只能在类的内部访问。

class Person (name: String, age: Int) {
}

可以改写成带访问权限的参数

class Person (private[this] val name: String, private[this] val age: Int) {
}

4、类的初始化语句

主构造器执行时，类中定义的语句作为初始化语句
在net.lym.day05包里创建Dog类

package net.lym.day05
/**
 * 功能：
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Dog(var name: String, var age: Int) {
  name = "瑞瑞"
  age = 5
  println("主构造器被调用")

  def speak(): Unit = println("我叫" + name + ",今年" + age + "岁了~")

}
// 伴生对象
object Dog{
  def main(args: Array[String]): Unit = {
    // 创建狗对象
    val dog = new Dog("",0)
    // 调用对象方法
    dog.speak()
  }

}

运行程序，查看结果

说明：实例化Dog时，传入的参数是""与0，但是会执行类里的两个给成员变量赋值的语句，于是name成了瑞瑞，age成了5，于是调用对象的speak()方法，会输出我叫瑞瑞，今年5岁了~。

5、私有化构造器

如果需要将整个主构造器设置为私有的，那么只需要添加private关键字即可，注意，只有伴生对象里才能调用私有构造器来实例化，非伴生对象里就不能调用私有构造器来实例化
在net.lym.day05包里创建Cat类

package net.lym.day05
/**
 * 功能：猫类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
//  伴生类
class Cat private(var name: String, var  age: Int){
  def speak(): Unit = {
    println("我叫" + name + ",今年" + age + "岁了~")
  }

}
//伴生对象
object Cat{
  def main(args: Array[String]): Unit = {
    val cat = new Cat("欢欢", 2)
    cat.speak()
  }

}

运行程序，查看结果

如果改成非伴生对象TestCat，报错：私有构造器不能被非伴生对象TestCat访问

将TestCat改名为Cat

6、无参构造器

主构造器也可以没有参数，一个类中如果没有显式地定义主构造器，就默认有一个无参构造器。
在net.lym.day05包里创建Bird类

package net.lym.day05
/**
 * 功能：鸟类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Bird() { // 显示定义无参构造器
  var name = "玲玲"
  var age = 4

  def speak(): Unit = {
    println("我叫" + name + ",今年" + age + "岁了~")
  }
}
// 伴生对象
object Bird{
  def main(args: Array[String]): Unit = {
    val bird = new Bird() // 调用无参构造器实列化
    bird.speak()
  }

}

运行程序，查看结果

其实，去掉类名Bird后面的()，系统依然会提供一个无参构造器，程序运行不会报错

package net.lym.day05
/**
 * 功能：鸟类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Bird { // 不显示定义无参构造器
  var name = "玲玲"
  var age = 4

  def speak(): Unit = {
    println("我叫" + name + ",今年" + age + "岁了~")
  }
}
// 伴生对象
object Bird{
  def main(args: Array[String]): Unit = {
    val bird = new Bird() // 调用无参构造器实列化
    bird.speak()
  }

}

（二）辅助构造器

Scala类除了可以有主构造器外，还可以有任意多个辅助构造器。

1、定义辅助构造器的注意事项

辅助构造器的方法名称为this
每一个辅助构造器的方法体中必须首先调用其他已定义的构造器
辅助构造器的参数不能使用var或val进行修饰

2、案例演示

（1）无参主构造器与有参辅助构造器

在net.lym.day05包里创建Student类

package net.lym.day05
/**
 * 功能：学生类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Student { //  非显示主构造器
  private var name = "李林芮"
  private var age = 18

  // 定义单参辅助构造器
  def this(name: String) = {
    this()  // 调用无参主构造器
    this.name = name
  }

  // 定义双参辅助构造器
  def  this(name: String,age: Int) = {
    this(name) // 调用单参辅助构造器
    this.age = age
  }
  // 重写toString方法
  override def toString: String = "我叫" + name + "，今年" + age + "，岁了~"
}
// 伴生对象
object Student{
  def main(args: Array[String]): Unit = {
    // 调用无参构造器实例化
    val student1 = new Student()
    println(student1)
    // 调用单参辅助构造器实例化
    val student2 = new Student("王晓琳")
    println(student2)
    // 调用双参辅助构造器实例化
    val  student3 = new Student("张智霖",21)
    println(student3)
  }

}

运行程序，查看结果

课堂练习：用Java程序来完成上述任务

package test;

/**
 * 功能：构造方法重载演示
 * 作者：柠檬
 * 日期：2023年03月30日
 */
public class Student {
    private String name = "李林芮";
    private int age = 18;

    // 无参构造方法
    public Student() {
    }

    // 单参构造方法
    public Student(String name) {
        this();  // 调用无参构造方法
        this.name = name;
    }

    // 双参构造方法
    public Student(String name, int age) {
        this(name);  // 调用单参构造方法
        this.age = age;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "我叫" + name + "，今年" + age + "岁了~";
    }

    public static void main(String[] args) {
        // 调用无参构造方法实例化
        Student student1 = new Student();
        System.out.println(student1);
        // 调用单参构造方法实例化
        Student student2 = new Student("王晓林");
        System.out.println(student2);
        // 调用双参构造方法实例化
        Student student3 = new Student("张智霖", 21);
        System.out.println(student3);
    }
}

运行程序，查看结果

（2）有参主构造器与有参辅助构造器

主构造器还可以与辅助构造器同时使用，在这种情况下，一般辅助构造器的参数要多于主构造器
在net.lym.day05包里创建Teacher类

package net.lym.day05
/**
 * 功能：教师类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Teacher(private var name: String,private var age: Int) { // 双参主构造器
  private var gender = ""

  // 三参辅助构造器
  def this(name: String,age: Int,gender: String) = {
    this(name, age) // 调用双参主构造器
    this.gender = gender
  }

  // 重写toString方法
  override def toString: String = "我叫" + name +","+gender+ "，今年" + age + "，岁了~"
}
// 伴生对象
object Teacher{
  def main(args: Array[String]): Unit = {
    // 调用三参辅助构造器实例化
    val teacher = new Teacher("无心剑",50,"男")
    println(teacher)
  }
}

运行程序，查看结果

六、抽象类

（一）抽象类的定义

Scala的抽象类使用关键字abstract定义

abstract class 类名 {

}

（二）抽象类的特征

抽象类不能被实例化。
抽象类中可以定义抽象字段（没有初始化的字段）和抽象方法（没有被实现的方法），也可以定义被初始化的字段和被实现的方法。
若某个子类继承了一个抽象类，则必须实现抽象类中的抽象字段和抽象方法，且实现的过程中可以添加override关键字，也可以省略。若重写了抽象类中已经实现的方法，则必须添加override关键字。

（三）案例演示

1、创建抽象类 - Person

在net.lym.day06包里创建Person抽象类

package net.lym.day06
/**
 * 功能：抽象人类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
abstract class Person {
  var name: String // 抽象字段
  var age: Int //抽象字段
  var address: String = "龙马潭区长桥路2号" // 普通字段

  // 抽象方法
  def speak()

  // 普通方法
  def walk(): Unit = {
    println(name + "在散步~")
  }
}

2、继承抽象类，创建普通类 - Teacher

在net.lym.day06包里创建Teacher普通类

package net.lym.day06
/**
 * 功能：教师类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
class Teacher extends Person {
  // 实现抽象字段（可以不加override）
  var  name: String = "无心剑"
  var age: Int = 50

  // 实现抽象方法，不用加override
  def speak(): Unit = {
    println("我叫" + name + "，今年" + age + "岁，家住" + address + "，擅长讲课与翻译~")
  }
  // 重写普通方法，必须加override
  override def walk(): Unit = {
    println("教师[" + name + "]喜欢雨中漫步~")
  }
}

3、创建测试对象 - TestTeacher

在net.lym.day06包里创建TestTeacher对象

package net.lym.day06
/**
 * 功能：测试教师类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
object TestTeacher {
  def main(args: Array[String]): Unit = {
    // 创建教师对象
    val teacher = new Teacher()
    // 调用对象方法
    teacher.speak()
    teacher.walk()
  }

}

4、运行程序，查看结果

运行TestTeacher对象

5、简要说明

需要注意的是，上述Teacher类中speak()方法的地址字段（address）是从父类（抽象类Person）中继承而来的。由于该字段在Person中有初始化值，不是抽象字段，若需要在Teacher类中修改该字段的值，则可以在Teacher类的构造函数或其它方法中使用this.address对其重新赋值。例如，将地址改为“江阳区前进中路3号”，可以使用以下代码：this.address="江阳区前进中路3号"。

运行TestTeacher对象，查看结果

七、特质

（一）特质的概念

Scala特质使用关键字trait定义，类似Java 8中使用interface定义的接口。特质除了有Java接口的功能外，还有一些特殊的功能。Scala特质中，字段和方法的定义与Scala抽象类一样，可以定义抽象字段和抽象方法、非抽象字段和非抽象方法。

（二）特质的定义

1、语法格式

trait 特质名 {
// 抽象字段
// 抽象方法
// 普通字段
// 普通方法
}

2、案例演示

任务1、创建宠物特质 - Pet

在net.lym.day07包里创建Pet特质

package net.lym.day07
/**
 * 功能：宠物特质
 * 作者：柠檬
 * 日期：2023年03月30日
 */
trait Pet {
  // 抽象字段
  var name: String
  var age: Int
  // 抽象方法
  def speak
  // 普通方法
  def eat: Unit = {
    println(name + "在吃东西~")
  }

}

任务2、创建奔跑特质 - Runnable

在net.lym.day07包里创建Runnable特质

package net.lym.day07
/**
 * 功能：奔跑特质
 * 作者：柠檬
 * 日期：2023年03月30日
 */
trait Runnable {
  // 抽象方法
  def  run
}

任务3、创建飞翔特质 - Flyable

在net.lym.day07包里创建Flyable特质

package net.lym.day07
/**
 * 功能：飞翔特质
 * 作者：柠檬
 * 日期：2023年03月30日
 */
trait Flyable {
  // 抽象方法
  def fly

}

（三）特质的实现

类可以使用关键字extends实现特质，但必须实现特质中未实现的字段和方法（抽象字段和抽象方法），这一点与继承抽象类是一致的。

1、语法格式

（1）实现一个特质

class 类名 extends 特质名 {
// 实现抽象字段
// 实现抽象方法
}

（2）实现多个特质

如果需要实现的特质不止一个，那么可以通过with关键字添加额外特质，但位于最左侧的特质必须使用extends关键字。

class 类名 extends 特质名1 with 特质名2 with 特质名3 …… with 特质名n {
// 实现抽象字段
// 实现抽象方法
}

2、案例演示

任务1、实现一个特质

在net.lym.day07包里创建Cat类，实现Pet特质

package net.lym.day07
/**
 * 功能：猫类
 * 作者：柠檬
 * 日期：2023年03月30日
 */
// 伴生类
class Cat extends Pet {
  //实现抽象字段
  var name:String = "虎丸"
  var age:Int = 3

  // 实现抽象方法
  def speak: Unit = {
    println("我叫" + name + "，今年" + age + "岁了~")
  }
  // 重写普通方法
  override def eat: Unit ={
    println(name + "在吃鱼虾~")

  }
}
// 伴生对象
object Cat{
  def main(args: Array[String]): Unit = {
    // 创建猫对象
    var cat = new Cat
    // 调用对象方法
    cat.speak
    cat.eat
  }

}

运行程序，查看结果

任务2、实现多个特质

在net.lym.day07包里创建Bird类，实现Pet、Runnable、Flyable特质

买一送二的方式（一专多能的情况）

package net.lym.day07
/**
 * 功能：鸟类
 * 作者：柠檬
 * 日期：2023年04月01日
 */
// 伴生类
class Bird extends Pet with Runnable with Flyable {
  override var name: String = "玲玲"
  override var age: Int = 2

  override def speak: Unit = {
    println("我叫" + name+ "，今年" + age + "岁了~")
  }

  override def run: Unit = {
    println("鸟儿[" + name + "]在欢快地奔跑~")
  }

  override def fly: Unit = {
    println("鸟儿[" + name + "]在自由地飞翔~")
  }
  // 伴生对象
}
object Bird{
  def main(args: Array[String]): Unit = {
    // 创建鸟对象
    val bird = new Bird()
    // 调用对象方法
    bird.speak
    bird.run
    bird.fly
  }

}

运行程序，查看结果

八、课后作业

任务：学生喂养三种宠物

创建Animal特质，包含抽象字段：name和age，抽象方法：speak和eat
实现Animal特质，创建Dog类，包含双参主构造器，实现抽象字段和抽象方法
实现Animal特质，创建Cat类，包含双参主构造器，实现抽象字段和抽象方法
实现Animal特质，创建Bird类，包含双参主构造器，实现抽象字段和抽象方法
创建Student类，包含单参name构造器，包含普通方法feed，参数animal是Animal类型，方法里调用animal的speak和eat方法
创建TestStudent单例对象

运行程序，查看结果