Scala编程

继承和抽象类

继承

 

类型判断

 

抽象类

 通过abstract关键字实现。

定义

如果类中有抽象字段或抽象方法，那么该类就是一个抽象类。

• 抽象字段：没有初始化值的变量
• 抽象方法：没有方法体

格式

abstract class 抽象类名{
    val/var 抽象字段名:类型
    def 方法名(参数:参数类型...):返回类型
}

抽象案例

 

 示例

//目的：抽象类更像是一个空数据模板，如果其他类继承这个抽象类，可以省去写很多抽象字段和方法
//细节：抽象类的子类：1.子类如果是抽象类，则不用重写父类的抽象方法。2.如果是普通类，必须重写父类所有抽象方法。
//抽象类无法直接创建对象
object ClassDemo01 {
  //添加一个抽象类，计算面积
  abstract class Shape {
    def area():Double
    def a1():Int
    def a2():Int
    def a3():Int
  }
  //创建正方形类和长方形类，继承自Shape，包含一个主构造器、面积计算方法
  class Square(var edge : Double) extends Shape {
    override def area: Double = edge * edge

    override def a1(): Int = ???

    override def a2(): Int = ???

    override def a3(): Int = ???
  }
  class Rectangle(var length : Double,var width : Double) extends Shape {
    override def area(): Double = length * width
  }

  def main(args: Array[String]): Unit = {
    val s1 = new Square(5)
    println(s1.area)
  }
}

匿名内部类

匿名内部类是继承了类的匿名子类对象，可直接用来创建实例对象。

语法

new 类名(){
    //重写类中所有的抽象内容
}

使用场景

• 当对对象方法（成员方法）仅调用一次时；
• 可作为方法参数进行传递；

示例

• 创建一个Person抽象类，并添加一个sayHello抽象方法；
• 定义一个show（）方法，该方法需要传入一个Person类型的对象，再调用Perosn类中sayHello（）方法；
• 添加main方法，通过匿名内部类的方式来创建Person类的子类对象，调用Person类中的sayHello（）方法；
• 调用show（）方法。

object ClassDemo02 {

  abstract class Person {
    def sayHello()
  }

  def show(p:Person) = p.sayHello()
  def main(args: Array[String]): Unit = {
    //调用Person类中的sayHello（）方法
    new Person {
      override def sayHello(): Unit = println("Hello,Scala!")
    }.sayHello()

    val p:Person = new Person() { //多态，子类指向父类
      override def sayHello(): Unit = println("Python")
    }
    show(p)
  }
}

案例：动物类

 需求

• 定义抽象动物类，属性包括：姓名，年龄，行为：跑步和吃饭。
• 定义猫类，重写吃饭方法，并定义独有抓老鼠方法。
• 定义狗类，重写吃饭方法，并定义独有看家方法。

目的

考察：继承、抽象类、类型转换；

步骤

• 定义抽象动物类（Animal），属性：姓名，年龄，行为：跑步，吃饭；
• 定义猫类（Cat）继承自动物类，重写吃饭方法，并定义该类独有的抓老鼠方法；
• 定义狗类（Dog）继承自动物类，重写吃饭方法，并定义该类独有的看家方法。

示例

object ClassDemo {

   abstract class Animal{
    var name = ""
    var age = 0

    def run(): Unit = println("run")
    def eat()
  }

  class Cat extends Animal{
    override def eat(): Unit = println("eat fish")

    def catchMouse(): Unit = println("catch mouse")
  }

  class Dog extends Animal{
    override def eat(): Unit = println("eat meat")

    def catchThief(): Unit = println("catch thief")
  }
  

  def main(args: Array[String]): Unit = {
    val animal:Animal = new Cat()
    if(animal.isInstanceOf[Cat]) {
      val cat = animal.asInstanceOf[Cat]
      cat.catchMouse()
    } else if(animal.isInstanceOf[Dog]) {
      val dog = animal.asInstanceOf[Dog]
      dog.catchThief()
    } else {
      println("not cat or dog")
    }
  }

}

 特质

特质入门

概述

在不影响当前继承体系的情况下，对某些类（或某些对象）的功能进行加强。例如，有猴子类和大象类，都有姓名年龄，以及吃的功能，但部分猴子通过马戏团的训练后，学会了骑独轮车，那独轮车这个功能不能定义到父类（动物类）或猴子类中，而是应该定义到特质中。Scala中特质要用关键字trait修饰。

特点

• 特质可以提高代码的复用性。
• 特质可以提高代码的扩展性和可维护性。
• 类与特质是继承关系，类与类只支持单继承，类与特质之间可以单继承也可以多继承。
• Scala 的特质中可以有普通字段、抽象字段、普通方法、抽象方法。
• 如果特质只有抽象内容也叫瘦接口，如果既有抽象内容又有具体内容叫做富接口。

　　注意：

1. 如果特质中只有抽象内容，这种特质叫：瘦接口；
2. 如果特质中既有抽象内容，又有具体内容，叫：富接口；

语法

定义特质

trait 特质名称{

}

继承特质

class 类名 extends 特质1 with 特质2{

}

示例1：类继承单个特质

object ClassDemo {

  trait Logger{
    def log(msg:String) //抽象方法
  }

  //继承trait
  class ConsoleLogger extends Logger{
    override def log(msg: String): Unit = println(msg)
  }


  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("hello scala")
  }

}

示例2：类继承多个trait

object ClassDemo {

  trait MsgSender{
    def send(msg:String) //抽象方法，表示发送消息
  }

  trait MsgReceiver{
    def receive()
  }

  class MsgWorker extends MsgSender with MsgReceiver{
    override def send(msg: String): Unit = println(s"发送消息：$msg")

    override def receive(): Unit = println("接收消息")
  }

  def main(args: Array[String]): Unit = {
    val worker = new MsgWorker
    worker.send("hello")
    worker.receive()
  }

}

示例3：object继承trait

 

示例4：演示trait中成员

 

对象混入traint

 在 Scala 中，类和特质之间无任何继承关系，但通过特定关键字让该类对象具有指定特质中的成员。

语法

val/var 对象名 = new 类 with 特质

示例

object ClassDemo {

  trait Logger{
    def log(): Unit = println("log..")
  }

  class User{

  }

  def main(args: Array[String]): Unit = {
    val user = new User with Logger
    user.log()//log..
  }

}

//如果trait中是抽象方法
object Class01 {

  trait Logger {
    def log(msg:String)
  }

  class User

  def main(args: Array[String]): Unit = {
    val u = new User with Logger {
      override def log(msg: String): Unit = println(msg)
    }
    u.log("123")
  }
}

使用trait实现适配器模式

 设计模式简介

概述

设计模式（Design Pattern）是解决特定问题的一系列套路。并不是语法规定，而是一套用来提高代码可复用性、可维护性、可读性、稳健性以及安全性的解决方案。

分类

设计模式一共23中，分为如下3类：

1. 创建型：需要创建对象的。常用模式有：单例模式，工厂方法模式；
2. 结构型：类，特质之间的关系架构。常用模式：适配器模式，装饰模式；
3. 行为型：类（或者特质）能够做什么。常用模式：模板方法模式，职责链模式；

适配器模式

当某个特质中有多个抽象方法，而我们只需要用到某个或某几个方法时不得不将该特质所有抽象方法重写。针对这种情况可以定义一个抽象类继承该特质，重写特质的所有方法，方法体为空。需要使用哪个方法只需要定义类继承抽象类，重写指定方法即可。

结构

trait 特质A{
      //抽象方法     
} 

abstract class 类B extends A { //适配器类
      //重写抽象方法，方法体为空

}

class 自定义类C extends 类B {
      //需要使用哪个方法，就重写哪个方法即可
}

示例

object ClassDemo {

  trait Play{
    def mid()
    def top()
    def adc()
    def jungle()
    def support()
  }

   abstract class Player extends Play{
     override def mid(): Unit = {}

     override def top(): Unit = {}

     override def adc(): Unit = {}

     override def jungle(): Unit = {}

     override def support(): Unit = {}
   }

  //新手类
  class GreenHand extends Player {
    override def support(): Unit = println("我是辅助")
  }

  def main(args: Array[String]): Unit = {
    val player = new GreenHand
    player.support()
  }

}

使用trait实现模板方法模式

 

使用trait实现职责链模式

 

trait的构造机制

 

trait继承class

 

案例：程序员