scala 基本介绍与用法（四）

class Person {
  var name = "super"

  def getName = this.name
}

class Student extends Person

object Main13 {
  def main(args: Array[String]): Unit = {
    val p1 = new Person()
    val p2 = new Student()

    p2.name = "张三"

    println(p2.getName)
  }
}

示例 | 单例对象继承

创建一个Student单例对象，让单例对象继承示例1中的Person类
设置单例对象的名字为"张三"，调用Student单例对象的getName方法

class Person {
  var name = "super"

  def getName = this.name
}

object Student extends Person

object Main13 {
  def main(args: Array[String]): Unit = {

    println(Student.getName)
  }
}

三十三、override和super

类似于Java语言，在子类中使用override需要来重写父类的成员，可以使用super来引用父类

子类要覆盖父类中的一个方法，必须要使用override关键字
使用override来重写一个val字段
使用super关键字来访问父类的成员方法

示例

定义一个Person类，包含
姓名字段（不可重新赋值）
获取姓名方法
定义一个Student类
重写姓名字段
重写获取姓名方法，返回"hello, " + 姓名
创建Student对象示例，调用它的getName方法

class Person {
  val name = "super"

  def getName = name
}

class Student extends Person {
  // 重写val字段
  override val name: String = "child"

  // 重写getName方法
  override def getName: String = "hello, " + super.getName
}

object Main13 {
  def main(args: Array[String]): Unit = {
    println(new Student().getName)
  }
}

三十四、类型判断

有时候，我们设计的程序，要根据变量的类型来执行对应的逻辑。

scala 基本介绍与用法（四）

在scala中有两种方式进行类型判断

isInstanceOf
getClass/classOf

isInstanceOf/asInstanceOf

在Java中，可以使用instanceof关键字来判断类型、以及(类型)object来进行类型转换，在scala中如何实现？

scala中对象提供isInstanceOf和asInstanceOf方法。

isInstanceOf判断对象是否为指定类的对象
asInstanceOf将对象转换为指定类型

用法

// 判断对象是否为指定类型

val trueOrFalse:Boolean = 对象.isInstanceOf[类型]

// 将对象转换为指定类型

val 变量 = 对象.asInstanceOf[类型]

示例

定义一个Person类
定义一个Student类继承自Person类
创建一个Student类对象
判断该对象是否为Student类型，如果是，将其转换为Student类型并打印该对象

class Person3
class Student3 extends Person3

object Main3 {
  def main(args: Array[String]): Unit = {
    val s1:Person3 = new Student3

    // 判断s1是否为Student3类型
    if(s1.isInstanceOf[Student3]) {
      // 将s1转换为Student3类型
      val s2 =  s1.asInstanceOf[Student3]
      println(s2)
    }

  }
}

getClass和classOf

isInstanceOf 只能判断对象是否为指定类以及其子类的对象，而不能精确的判断出，对象就是指定类的对象。如果要求精确地判断出对象就是指定类的对象，那么就只能使用 getClass 和 classOf 。

用法

p.getClass可以精确获取对象的类型
classOf[x]可以精确获取类型
使用==操作符可以直接比较类型

示例

定义一个Person类
定义一个Student类继承自Person类
创建一个Student类对象，并指定它的类型为Person类型
测试使用isInstance判断该对象是否为Person类型
测试使用getClass/classOf判断该对象是否为Person类型
测试使用getClass/classOf判断该对象是否为Student类型

class Person4
class Student4 extends Person4

object Student4{
  def main(args: Array[String]) {
    val p:Person4=new Student4
    //判断p是否为Person4类的实例
    println(p.isInstanceOf[Person4])//true

    //判断p的类型是否为Person4类
    println(p.getClass == classOf[Person4])//false

    //判断p的类型是否为Student4类
    println(p.getClass == classOf[Student4])//true
  }
}

三十五、抽象类

和Java语言一样，scala中也可以定义抽象类

定义

如果类的某个成员在当前类中的定义是不包含完整的，它就是一个抽象类

不完整定义有两种情况：

方法没有方法体（抽象方法）
变量没有初始化（抽象字段）

定义抽象类和Java一样，在类前面加上abstract关键字

// 定义抽象类

abstract class 抽象类名 {

// 定义抽象字段

val 抽象字段名:类型

// 定义抽象方法

def 方法名(参数:参数类型,参数:参数类型...):返回类型

}

抽象方法

scala 基本介绍与用法（四）

设计4个类，表示上述图中的继承关系
每一个形状都有自己求面积的方法，但是不同的形状计算面积的方法不同

步骤

创建一个Shape抽象类，添加一个area抽象方法，用于计算面积
创建一个Square正方形类，继承自Shape，它有一个边长的主构造器，并实现计算面积方法
创建一个长方形类，继承自Shape，它有一个长、宽的主构造器，实现计算面积方法
创建一个圆形类，继承自Shape，它有一个半径的主构造器，并实现计算面积方法
编写main方法，分别创建正方形、长方形、圆形对象，并打印它们的面积

// 创建形状抽象类
abstract class Shape {
  def area:Double
}

// 创建正方形类
class Square(var edge:Double /*边长*/) extends Shape {
  // 实现父类计算面积的方法
  override def area: Double = edge * edge
}

// 创建长方形类
class Rectangle(var length:Double /*长*/, var width:Double /*宽*/) extends Shape {
  override def area: Double = length * width
}

// 创建圆形类
class Cirle(var radius:Double /*半径*/) extends Shape {
  override def area: Double = Math.PI * radius * radius
}

object Main6 {
  def main(args: Array[String]): Unit = {
    val s1:Shape = new Square(2)
    val s2:Shape = new Rectangle(2,3)
    val s3:Shape = new Cirle(2)

    println(s1.area)
    println(s2.area)
    println(s3.area)
  }
}

三十六、抽象字段

在scala中，也可以定义抽象的字段。如果一个成员变量是没有初始化，我们就认为它是抽象的。

abstract class 抽象类 {

val/var 抽象字段:类型

}

创建一个Person抽象类，它有一个String抽象字段WHO_AM_I
创建一个Student类，继承自Person类，重写WHO_AM_I字段，初始化为学生
创建一个Policeman类，继承自Person类，重写WHO_AM_I字段，初始化警察
添加main方法，分别创建Student/Policeman的实例，然后分别打印WHO_AM_I

// 定义一个人的抽象类
abstract class Person6 {
  // 没有初始化的val字段就是抽象字段
  val WHO_AM_I:String
}

class Student6 extends Person6 {
  override val WHO_AM_I: String = "学生"
}

class Policeman6 extends Person6 {
  override val WHO_AM_I: String = "警察"
}

object Main6 {
  def main(args: Array[String]): Unit = {
    val p1 = new Student6
    val p2 = new Policeman6

    println(p1.WHO_AM_I)
    println(p2.WHO_AM_I)
  }
}

三十七、匿名内部类

匿名内部类是没有名称的子类，直接用来创建实例对象。Spark的源代码中有大量使用到匿名内部类。

scala中的匿名内部类使用与Java一致。

val/var 变量名 = new 类/抽象类 {

// 重写方法

}

创建一个Person抽象类，并添加一个sayHello抽象方法
添加main方法，通过创建匿名内部类的方式来实现Person
调用匿名内部类对象的sayHello方法

abstract class Person7 {
  def sayHello:Unit
}

object Main7 {
  def main(args: Array[String]): Unit = {
    // 直接用new来创建一个匿名内部类对象
    val p1 = new Person7 {
      override def sayHello: Unit = println("我是一个匿名内部类")
    }
    p1.sayHello
  }
}

三十八、特质(trait)

scala中没有Java中的接口（interface），替代的概念是——特质

特质是scala中代码复用的基础单元
它可以将方法和字段定义封装起来，然后添加到类中
与类继承不一样的是，类继承要求每个类都只能继承一个超类，而一个类可以添加任意数量的特质。
特质的定义和抽象类的定义很像，但它是使用trait关键字

定义特质

trait 名称 {

// 抽象字段

// 抽象方法

}

继承特质

class 类 extends 特质1 with 特质2 {

// 字段实现

// 方法实现

}

使用extends来继承trait（scala不论是类还是特质，都是使用extends关键字）
如果要继承多个trait，则使用with关键字

trait作为接口使用

trait作为接口使用，与java的接口使用方法一样。

示例 | 继承单个trait

创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法
创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息
添加main方法，创建ConsoleLogger对象，调用log方法

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

  class ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台日志:" + message)
  }

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("这是一条日志")
  }

示例 | 继承多个trait

创建一个MessageSender特质，添加send方法
创建一个MessageReceiver特质，添加receive方法
创建一个MessageWorker实现这两个特质
在main中调用，分别调用send方法、receive方法

trait MessageSender {
    def send(msg:String)
}

trait MessageReceive {
    def receive():String
}

class MessageWorker extends MessageSender with MessageReceive {
    override def send(msg: String): Unit = println(s"发送消息:${msg}")

    override def receive(): String = "你好！我叫一个好人！"
}

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

示例 | object继承trait

创建一个Logger特质，添加一个log抽象方法
创建一个ConsoleLogger的object，实现LoggerForObject特质，实现log方法，打印消息
编写main方法，调用ConsoleLogger的log方法

trait Logger {
    def log(message:String)
}

object ConsoleLogger extends Logger {
    override def log(message: String): Unit = println("控制台消息:" + message)
}

def main(args: Array[String]): Unit = {
    ConsoleLogger.log("程序退出!")
}

三十九、特质 | 定义具体的方法

和类一样，trait中还可以定义具体的方法

定义一个Logger特质，添加log实现方法
定义一个UserService类，实现Logger特质

添加add方法，打印"添加用户"

3．添加main方法

创建UserService对象实例
调用add方法

trait LoggerDetail {
  // 在trait中定义具体方法
  def log(msg:String) = println(msg)
}

class UserService extends LoggerDetail {
  def add() = log("添加用户")
}

object MethodInTrait {
  def main(args: Array[String]): Unit = {
    val userService = new UserService
    userService.add()
  }
}

四十、trait中定义具体的字段和抽象的字段

在trait中可以定义具体字段和抽象字段
继承trait的子类自动拥有trait中定义的字段
字段直接被添加到子类中

通过trait来实现一个日志输出工具，该日志工具可以自动添加日志的日期

创建Logger特质

定义一个SimpleDateFormat字段，用来格式化日期（显示到时间）
定义一个TYPE抽象字段，用于定义输出的信息
创建一个log抽象方法，用于输出日志

创建ConsoleLogger类，实现TYPE抽象字段和log方法
添加main方法

创建ConsoleLogger类对象
调用log方法

 trait Logger {
    val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
    def log(msg:String)
  }

  class ConsoleLogger extends Logger {
    override def log(msg: String): Unit = {
      val info = s"${sdf.format(new Date())}:控制台消息:${msg}"
      println(info)
    }
  }

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

四十一、使用trait实现模板模式

要实现以下需求：

实现一个输出日志的功能
目前要求输出到控制台
将来可能会输出到文件、输出到Redis、或者更多的需求

如何实现将来不修改之前的代码，来扩展现有功能呢？

scala 基本介绍与用法（四）

定义

在一个特质中，具体方法依赖于抽象方法，而抽象方法可以放到继承trait的子类中实现，这种设计方式也称为模板模式

scala 基本介绍与用法（四）

在scala中，trait是可以定义抽象方法，也可以定义具体方法的

trait中定义了一个抽象方法
trait中定义了其他的几个具体方法，会调用抽象方法
其他实现类可以来实现抽象方法
真正调用trait中具体方法的时候，其实会调用实现类的抽象方法实现

示例

编写一个日志输出工具，分别有info、warn、error三个级别的日志输出
日志输出的方式要求设计为可扩展的，例如：可以输出到控制台、将来也可以扩展输出到文件、数据库等

实现步骤

添加一个Logger特质

添加一个log抽象方法
添加一个info、warn、error具体方法，这几个方法调用log抽象方法

创建ConsoleLogger类，实现Logger特质
添加main方法

创建ConsoleLogger类对象
分别调用info、warn、error方法输出日志

  trait Logger {
    def log(msg:String)
    def info(msg:String) = log("INFO:" + msg)
    def warn(msg:String) = log("WARN:" + msg)
    def error(msg:String) = log("ERROR:" + msg)
  }

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

  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.info("信息日志")
    logger.warn("警告日志")
    logger.error("错误日志")
  }

四十二、对象混入trait

scala中可以将trait混入到对象中，就是将trait中定义的方法、字段添加到一个对象中

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

示例

给一个对象添加一些额外的行为

步骤

创建一个Logger特质

添加一个log实现方法，打印参数

创建一个UserService类
添加main方法

创建UserService对象，混入Logger特质
调用log方法

  trait Logger {
    def log(msg:String) = println(msg)
  }

  class UserService

  def main(args: Array[String]): Unit = {
    val service = new UserService with Logger
    service.log("混入的方法")
  }

四十三、trait实现调用链模式

我们如果要开发一个支付功能，往往需要执行一系列的验证才能完成支付。例如：

进行支付签名校验
数据合法性校验
...

如果将来因为第三方接口支付的调整，需要增加更多的校验规则，此时如何不修改之前的校验代码，来实现扩展呢？

责任链模式

scala 基本介绍与用法（四）

trait调用链

scala 基本介绍与用法（四）

类继承了多个trait后，可以依次调用多个trait中的同一个方法，只要让多个trait中的同一个方法在最后都依次执行super关键字即可。类中调用多个tait中都有这个方法时，首先会从最右边的trait方法开始执行，然后依次往左执行，形成一个调用链条。

示例

实现一个模拟支付过程的调用链

scala 基本介绍与用法（四）

步骤

1.定义一个HandlerTrait特质

定义一个具体的handler方法，打印"处理数据..."

2.定义一个DataValidHandlerTrait，继承HandlerTrait特质

重写handler方法，打印"验证数据"
调用父特质的handler方法

3.定义一个SignatureValidHandlerTrait，继承HandlerTrait特质

重写Handler方法
打印"检查签名"
调用父特质的handler方法

4.创建一个PaymentService类

继承DataValidHandlerTrait
继承SignatureValidHandlerTrait
定义pay方法

打印"准备支付"

调用父特质的handler方法

5.添加main方法

创建PaymentService对象实例
调用pay方法

trait HandlerTrait {
   def handle(data:String) = println("处理数据...")
}

trait DataValidHanlderTrait extends HandlerTrait {
   override def handle(data:String): Unit = {
       println("验证数据...")
       super.handle(data)
  }
}

trait SignatureValidHandlerTrait extends HandlerTrait {
   override def handle(data: String): Unit = {
       println("校验签名...")
       super.handle(data)
  }
}

class PayService extends DataValidHanlderTrait with SignatureValidHandlerTrait {
   override def handle(data: String): Unit = {
       println("准备支付...")
       super.handle(data)
  }
}

def main(args: Array[String]): Unit = {
   val service = new PayService
   service.handle("支付参数")
}

// 程序运行输出如下：
// 准备支付...
// 检查签名...
// 验证数据...
// 处理数据...

四十四、trait继承class

定义

trait也可以继承class的。特质会将class中的成员都继承下来。

示例

定义一个特质，继承自一个class

步骤

1.创建一个MyUtils类，定义printMsg方法

2.创建一个Logger特质，继承自MyUtils，定义log方法

3.创建一个Person类，添加name字段

继承Logger特质
实现sayHello方法，调用log方法

4.添加main方法，创建一个Person对象，调用sayHello方法

class MyUtil {
   def printMsg(msg:String) = println(msg)
}

trait Logger extends MyUtil {
   def log(msg:String) = printMsg("Logger:" + msg)
}

class Person extends Logger {
   def sayHello() = log("你好")
}

def main(args: Array[String]): Unit = {
   val person = new Person
   person.sayHello()
}

相关标签： scala scala 基本介绍与用法

上一篇： [java]一维数组

下一篇： Java一维数组

scala 基本介绍与用法（四）

三十二、继承

定义语法

示例 | 类继承

示例 | 单例对象继承

三十三、override和super

三十四、类型判断

isInstanceOf/asInstanceOf

getClass和classOf

三十五、抽象类

抽象方法

三十六、抽象字段

三十七、匿名内部类

三十八、特质(trait)

trait作为接口使用

示例 | 继承单个trait

示例 | 继承多个trait

示例 | object继承trait

三十九、特质 | 定义具体的方法

四十、trait中定义具体的字段和抽象的字段

四十一、使用trait实现模板模式

定义

四十二、对象混入trait

四十三、trait实现调用链模式

责任链模式

trait调用链

四十四、trait继承class

深入SQL Cursor基本用法的详细介绍

PHP数组基本用法与知识点总结

python3解析库BeautifulSoup4的安装配置与基本用法

jqGrid的基本用法与代码实例

脚手架vue-cli系列四：vue-cli工程webpack的基本用法

Python中字符串String的基本内置函数与过滤字符模块函数的基本用法

nginx 基本配置与参数说明详细介绍

桃仁的介绍与用法

在css3中background-clip属性与background-origin属性的用法介绍

Python中slots属性介绍与基本使用方法

scala 基本介绍与用法（四）

三十二、继承

定义语法

示例 | 类继承

示例 | 单例对象继承

三十三、override和super

三十四、类型判断

isInstanceOf/asInstanceOf

getClass和classOf

三十五、抽象类

抽象方法

三十六、抽象字段

三十七、匿名内部类

三十八、特质(trait)

trait作为接口使用

示例 | 继承单个trait

示例 | 继承多个trait

示例 | object继承trait

三十九、特质 | 定义具体的方法

四十、trait中定义具体的字段和抽象的字段

四十一、使用trait实现模板模式

定义

四十二、对象混入trait

四十三、trait实现调用链模式

责任链模式

trait调用链

四十四、trait继承class

深入SQL Cursor基本用法的详细介绍

PHP数组基本用法与知识点总结

python3解析库BeautifulSoup4的安装配置与基本用法

jqGrid的基本用法与代码实例

脚手架vue-cli系列四：vue-cli工程webpack的基本用法

Python中字符串String的基本内置函数与过滤字符模块函数的基本用法

nginx 基本配置与参数说明详细介绍

桃仁的介绍与用法

在css3中background-clip属性与background-origin属性的用法介绍

Python中__slots__属性介绍与基本使用方法

Python中slots属性介绍与基本使用方法