大数据必学语言Scala（三十一）：scala面向对象 特质(trait)

已于 2022-05-17 16:43:18 修改
阅读量1.8k 收藏 5
点赞数 14
分类专栏： 大数据必学语言Scala 文章标签： 特质trait
于 2021-05-11 00:08:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoweite1/article/details/116616222
版权

文章目录

特质(trait)

作为接口使用

定义具体的方法

定义具体方法和抽象方法

定义具体的字段和抽象的字段

实例对象混入trait

trait调用链 

trait的构造机制

trait继承class

特质(trait)

OLTP = online transaction processing

大数据：OLAP = online analysis processing

scala中没有interfact的接口

可以用trait来实现接口的功能。

同时trait比接口更强大

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

1. trait 中可以有 抽象的 也可以有 具体的
2. 一个类可以实现多个trait（通过with关键字）
3. 单个对象也可以附件多个trait
4. trait本身也可以继承其它class
通过这3个特性，我们可以体现出来。trait是一种 代码复用的最小单元
我们可以将想要的特性功能封装到trait中
不管是让class去附加 还是单个对象去附加 都OK
同时附加的数量不受到影响。

接下来，我们就来学习trait的几种用法。

作为接口使用

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

案例1：继承单个trait

实现步骤：

创建一个Logger特质，添加一个接受一个String类型参数的log抽象方法

创建一个ConsoleLogger类，继承Logger特质，实现log方法，打印消息

添加main方法，创建ConsoleLogger对象，调用log方法

示例代码：

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

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

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

案例2：继承多个trait

实现步骤：

在上一个案例的基础上，创建一个MessageSender特质，添加接受一个String类型参数的send方法

再让ConsoleLogger实现一个MessageSender特质，并实现它的send方法，打印"发送消息..."

在main中调用，send方法

示例代码：

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

trait MessageSender {
  def send(msg:String)
}

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

  override def send(msg: String): Unit = println(s"发送消息:${msg}")
}

object LoggerTrait {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLogger
    logger.log("控制台日志: 这是一条Log")
    logger.send("你好!")
  }
}

案例3：object继承trait

实现步骤：

创建一个LoggerForObject特质，添加一个接受一个String类型参数的log抽象方法

创建一个ConsoleLogger的object，实现LoggerForObject特质，实现log方法，打印消息

编写main方法，调用ConsoleLogger的log方法

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

// object也可以继承trait
object ConsoleLogger extends LoggerForObject {
  override def log(msg: String): Unit = println(s"控制台信息 $msg")
}

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

在trait中可以定义抽象方法，不写方法体就是抽象方法

和继承类一样，使用extends来继承trait

继承多个trait，使用with关键字

单例对象也可以继承trait

定义具体的方法

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

案例：在trait中定义具体方法

实现步骤：

1. 定义一个LoggerDetail特质

- 添加接受一个String类型的log方法，并打印参数

2. 定义一个UserService类，实现LoggerDetail特质

-  添加add方法，调用log方法打印"添加用户"

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的子类中实现，这种设计方式也称为模板模式

案例：实现一个模板模式

实现步骤：

1. 添加一个LoggerFix特质

- 添加一个log抽象方法，接收String参数

- 添加一个info具体方法，接收String参数，调用log方法，参数添加"INFO:"

- 添加一个warn具体方法，接收String参数，调用log方法，参数添加"WARN:"

- 添加一个error具体方法，接收String参数，调用log方法，参数添加"ERROR:"

2. 创建ConsoleLoggerFix类

- 实现LoggerFix特质

- 实现log方法，打印参数

3. 添加main方法

- 创建ConsoleLoggerFix类对象

- 调用info方法

- 调用warn方法

- 调用error方法

示例代码：

trait Logger08 {
  // 抽象方法
  def log(msg:String)
  // 具体方法（该方法依赖于抽象方法log
  def info(msg:String) = log("INFO:" + msg)
  def warn(msg:String) = log("WARN:" + msg)
  def error(msg:String) = log("ERROR:" + msg)
}

class ConsoleLogger08 extends Logger08 {
  override def log(msg: String): Unit = println(msg)
}

object Trait08 {
  def main(args: Array[String]): Unit = {
    val logger08 = new ConsoleLogger08

    logger08.info("这是一条普通信息")
    logger08.warn("这是一条警告信息")
    logger08.error("这是一条错误信息")
  }
}

定义具体的字段和抽象的字段

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

案例：在trait中定义具体的字段和抽象的字段

实现步骤：

1. 创建LoggerEx特质

- 定义一个sdf具体字段，类型为SimpleDateFormat，用来格式化日志（显示到时间）

- 创建一个INFO具体字段，类型为String，初始化为："信息:当前日期"

- 创建一个TYPE抽象字段，类型为String

- 创建一个log抽象方法，参数为String类型

2. 创建ConsoleLoggerEx类

- 实现LoggerEx特质

- 实现TYPE抽象字段，初始化为"控制台"

- 实现log抽象方法，分别打印TYPE字段，INFO字段和参数

3. 添加main方法

- 创建ConsoleLoggerEx类对象

- 调用log方法

示例代码：

trait LoggerEx {
  // 具体字段
  val sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm")
  val INFO = "信息:" + sdf.format(new Date)
  // 抽象字段
  val TYPE:String

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

class ConsoleLoggerEx extends LoggerEx {
  // 实现抽象字段
  override val TYPE: String = "控制台"
  // 实现抽象方法
  override def log(msg:String): Unit = print(s"$TYPE$INFO $msg")
}

object FieldInTrait {
  def main(args: Array[String]): Unit = {
    val logger = new ConsoleLoggerEx

    logger.log("这是一条消息")
  }
}

实例对象混入trait

  • trait还可以混入到实例对象中，给对象实例添加额外的行为
  • 只有混入了trait的对象才具有trait中的方法，其他的类对象不具有trait中的行为
  • 使用with将trait混入到实例对象中

案例：将一个特质混入到一个对象中

实现步骤：

1. 创建一个LoggerMix混入

- 添加一个log方法，参数为String类型

- 打印参数

2. 创建一个UserService类

3. 添加main方法

- 创建UserService对象，还如LoggerMix特质

- 调用log方法

示例代码：

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

class UserService

object FixedInClass {
  def main(args: Array[String]): Unit = {
    // 使用with关键字直接将特质混入到对象中
    val userService = new UserService with LoggerMix

    userService.log("你好")
  }
}

trait调用链 

责任链模式

需求：

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

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

实现步骤：

1. 定义一个HandlerTrait特质

- 定义一个具体的handler方法，接收String参数，打印"处理数据..."

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 DataValidHandlerTrait extends HandlerTrait {
  override def handle(data: String) = {
    println("验证数据...")
    super.handle(data)
  }
}

// 签名校验处理
trait SignatureValidHandlerTrait extends HandlerTrait {
  override def handle(data: String) = {
    println("检查签名...")
    super.handle(data)
  }
}

// 支付服务
class PaymentService extends DataValidHandlerTrait with SignatureValidHandlerTrait {
  def pay(data:String) = {
    println("准备支付...")
    this.handle(data)
  }
}

object PaymentService {
  def main(args: Array[String]) {
    val payService = new PaymentService()
    payService.pay("signature:10233123||md5:123889a3d5s1f6123||data:{order:001,money:200}")
  }
}

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

trait的构造机制

责任链模式和类构造顺序不同

责任链（指的是对父类方法的调用）：

  • 从右向左， 同层优先

父类构造顺序：

  • 从左到右，父类优先
  • trait也有构造代码，但和类不一样，特质不能有构造器参数
  • 每个特质只有一个无参数的构造器。
  • 一个类继承另一个类、以及多个trait，当创建该类的实例时，它的构造顺序如下：
  1. 执行父类的构造器
  2. 从左到右依次执行trait的构造器
  3. 如果trait有父trait，先构造父trait，如果多个trait有同样的父trait，则只初始化一次
  4. 执行子类构造器

案例：演示trait的构造顺序

实现步骤：

  1. 创建一个Person_One特质，在构造器中打印"执行Person构造器!"
  2. 创建一个Logger_One特质，在构造器中打印"执行Logger构造器!"
  3. 创建一个MyLoggerOne特质，继承自LoggerOne特质，，在构造器中打印"执行MyLogger构造器!"
  4. 创建一个TimeLoggerOne特质，继承自LoggerOne特质，在构造器中打印"执行TimeLogger构造器!"
  5. 创建一个StudentOne类，继承自PersonOne、MyLoggerOne、TimeLoggerOne特质，在构造器中打印"执行Student构造器!"
  6. 添加main方法，实例化Student_One类，观察输出。

示例代码：

class Person_One {
  println("执行Person构造器!")
}
trait Logger_One {
  println("执行Logger构造器!")
}
trait MyLogger_One extends Logger_One {
  println("执行MyLogger构造器!")
}
trait TimeLogger_One extends Logger_One {
  println("执行TimeLogger构造器!")
}
class Student_One extends Person_One with MyLogger_One with TimeLogger_One {
  println("执行Student构造器!")
  }
object exe_one {
  def main(args: Array[String]): Unit = {
    val student = new Student_One
  }
}

// 程序运行输出如下：
// 执行Person构造器!
// 执行Logger构造器!
// 执行MyLogger构造器!
// 执行TimeLogger构造器!
// 执行Student构造器!

trait继承class

  • trait也可以继承class
  • 这个class就会成为所有该trait子类的超级父类。

单个实例对象附加trait的时候， 无法在任何地方调用trait父类的成员

必须是class继承trait才可以

案例：定义一个特质，继承自一个class

实现步骤：

1. 创建一个MyUtils类

- 定义printMsg方法，接收String参数，并打印参数

2. 创建一个Logger_Two特质

- 继承自MyUtils

- 定义log方法，接收String参数，并打印一个前缀和参数

3. 创建一个Person_Three类

- 实现String类型name字段的主构造器

- 继承Logger_Two特质

- 实现sayHello方法

  • 调用log，传入"Hi， I‘m "加上name字段
  • 调用printMsg，传入"Hello, I'm "加上name字段

4. 添加main方法

- 创建一个Person_Three对象

- 调用sayHello方法

示例：

class MyUtil {
  def printMsg(msg: String) = println(msg)
}
trait Logger_Two extends MyUtil {
  def log(msg: String) = this.printMsg("log: " + msg)
}
class Person_Three(val name: String) extends Logger_Two {
    def sayHello {
        this.log("Hi, I'm " + this.name)
        this.printMsg("Hello, I'm " + this.name)
  }
}
object Person_Three{
  def main(args: Array[String]) {
      val p=new Person_Three("Tom")
      p.sayHello
    //执行结果：
//      log: Hi, I'm Tom
//      Hello, I'm Tom
  }
}
  • 📢博客主页：https://lansonli.blog.csdn.net
  • 📢欢迎点赞 👍 收藏 ⭐留言 📝 如有错误敬请指正！
  • 📢本文由 Lansonli 原创，首发于 CSDN博客🙉
  • 📢停下休息的时候不要忘了别人还在奔跑，希望大家抓紧时间学习，全力奔赴更美好的生活✨
Lansonli
关注
  • 14
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
订阅专栏
Scala编程详解 第13讲-Scala编程详解：面向对象编程之对象 共9页.pptx
11-25
第15讲-Scala编程详解：面向对象编程之Trait 共14页 第16讲-Scala编程详解：函数式编程 共14页 第17讲-Scala编程详解：函数式编程之集合操作 共9页 第18讲-Scala编程详解：模式匹配 共11页 第19讲-Scala编程详解：...
Scala特质 trait练习
qq_43012693的博客
10-24 188
package Test4 trait Type1{ def wheele:String={ "有四个轮子" } def run() } trait Type2{ def load:String={ "可以载人" } } abstract class CarTrait { def brand:String def engine:String var didi:String } class BM extends CarTrait with Type1 with T
快学Scala习题解答—第十章 特质
PEAK
12-16 1713
11 特质 11.1 java.awt.Rectangle类有两个很有用的方法translate和grow,但可惜的是像java.awt.geom.Ellipse2D这样的类没有。在Scala中，你可以解决掉这个问题。定义一个RenctangleLike特质,加入具体的translate和grow方法。提供任何你需要用来实现的抽象方法,以便你可以像如下代码这样混入该特质: va
9 scala的类继承及trait
最新发布
foshansuperinter的博客
02-11 1240
Trait（特质）是 Scala 中一种非常有用的机制，可以用于定义对象的特定特征或行为。Trait类似于 Java 中的接口。Trait与抽象类Trait可以被多重继承，一个类可以扩展多个Trait，但只能继承一个抽象类。Trait不能接受构造参数，但抽象类可以。Trait与 抽象类 的语义不同，Trait更适合描述对象的特征或行为，以及对象之间的has-a或can-do关系。抽象类更适合描述is-a关系，即子类是父类的一种特定类型。/*** 定义一个球员类* @param name 球员姓名。
scala习题（十）——特质
柯瓦特罗
01-03 1584
重点章节，与java有着比较大的分歧
Scala练习题
wzc8961661的博客
04-05 3811
目录题目第一题第二题第三题第四题第五题第六题第七题第八题第九题第十题第十一题第十二题第十三题第十四题第十五题第十六题第十七题第十八题第十九题第二十题第二十一题第二十二题第二十三题第二十四题 题目 1、创建一个demo1的单例，在demo1中创建一个样例类名字为student1，成员变量为name:String, age:Int 创建主方法实例化student，并传参数（“xiaoming”,20）...
scala入门系列(四) - extends abstract trait
潇洒人生的博客
04-30 327
object AbsApp { def main(args: Array[String]): Unit = { val a = new A println(a.eat) println( a.say) // println(a.run()) } } //*********extends 后面可以跟 abstract 或 trait with 后面 必须是 t...
Scala编程详解 第14讲-Scala编程详解：面向对象编程之继承 共13页.pptx
11-25
第15讲-Scala编程详解：面向对象编程之Trait 共14页 第16讲-Scala编程详解：函数式编程 共14页 第17讲-Scala编程详解：函数式编程之集合操作 共9页 第18讲-Scala编程详解：模式匹配 共11页 第19讲-Scala编程详解：...
Scala编程详解 第12讲-Scala编程详解：面向对象编程之类 共12页.pptx
11-25
第15讲-Scala编程详解：面向对象编程之Trait 共14页 第16讲-Scala编程详解：函数式编程 共14页 第17讲-Scala编程详解：函数式编程之集合操作 共9页 第18讲-Scala编程详解：模式匹配 共11页 第19讲-Scala编程详解：...
Scala 【 8 面向对象编程 – 继承 】
01-20
面向对象编程 – 继承 复用 ~ 可扩展性 ~ 可维护性 extends 使用 extends 关键字表示继承。 继承就代表，子类可以从父类继承父类的 field 和 method 。子类可以在自己内部放入父类所没有的子类特有的 field 和 ...
大数据课程-Scala编程基础-1.Scala语言初识_lk_edit.ppt
01-01
大数据课程——Scala编程基础，教师版，提供教学大纲、教案、教学设计、实训文档等，课程内容包含教学准备环境、软件安装、作业、教学文档、演示视频，花费巨额时间亲自制作，下载后可私信提供上述所有教学资料，可...
Scala-11：面向对象04-特质(Trait)
weixin_46429290的博客
08-17 219
Scala-11：面向对象04-特质(Trait) 一、概述 Scala 语言中，采用特质 trait（特征）来代替接口的概念，也就是说，多个类具有相同的特质（特征）时，就可以将这个特质（特征）独立出来，采用关键字 trait 声明。 Scala 中的 trait 中即可以有抽象属性和方法，也可以有具体的属性和方法，一个类可以混入（ mixin）多个特质。这种感觉类似于 Java 中的抽象类。 Scala 引入 trait 特征，第一可以替代 Java 的接口，第二个也是对单继承机制的一种补充。 二、特质声
scala学习13之与trait同名的object对象
Keep Learning
05-20 1990
一个class可以有一个伴生对象object，主要用来实现类似于java的静态属性和方法 同样trait也可以用类似的object，不确定叫不叫伴生对象，但功能可以调用在一个文件里面定义同名的trait和objectpackage org.bdgenomics.adam.test/** * Created by xubo on 2016/5/20. */ object objectTrai
Scala 的特质
CodeFlight
08-23 214
文章目录Scala 的特质特质瘦接口和富接口可堆叠修改（Stackable Modifications）线性化（linearization）特质的使用建议 Scala 的特质 特质是 Scala 重用代码的基础单元。特质可以封装方法和字段定义，通过混入（mix in）到相关的类，来达到复用的目的。和类的单继承不同的是，一个类可以混入多个特质 特质 可以像定义类来定义特质，只是需要将关键字 class 换成 trait trait Foo { // ... } 细节： 1.如果特质在定义时，没有
Scala特质
大数据跟我学i
03-13 412
文章目录特质入门1.概述2.特点3.语法4.类继承多个特质 特质入门 1.概述 有些时候，我们会遇到一些特定的需求，即：在不影响当前继承体系的情况下，对某些类(或者某些对象)的功能进行加强，例如：有猴子类和大象类，它们都有姓名、年龄以及吃的功能，但是部分的猴子经过马戏团的训练后，学会了骑独轮车，那骑独轮车就不能定义到父类(动物类)或者猴子类中，而是定义到特质中，而Scala中的特质，要用关键字srait修饰 2.特点 特质可以提高代码的复用性 特质可以提高代码的扩展性和可维护性 类特质之间是继承关系，类跟
scala自学之路-26-特质的应用01
u012045045的博客
03-04 257
trait Logger { def log(msg: String) } //子特质实现父特质里面的抽象方法 trait ConsoleLogger extends Logger { override def log(msg: String): Unit = println(msg) } //给日志加上一个时间戳 trait TimestampLogger extends ConsoleLogger { override de...
Scala-特质（Trait）
qq_53481973的博客
08-08 259
Scala-特质（Trait）
10-特质-Scala
GYT0313
04-12 284
前言 本节将介绍Scala 中的特质。 特质是Scala 代码附中的基础单元。特质将方法和字段定义封装起来，然后通过将它们混入类的方式来实现复用。不同于类继承，类可以同时混入任意数量的特质。 环境： Windows + Scala-2.12.8 1. 特质如何工作 特质和类的定义很像，如： 12.1.scala trait Run { def running() = { println...
scala 是完全面向对象的语言吗
06-10
Scala 中的类可以继承自其他类、混入（mixin）特质（trait）等，这些特性使得 Scala 可以更灵活、更强大地进行面向对象编程。 因此，Scala 是一种混合了函数式编程和面向对象编程的编程语言，它可以根据需要使用这...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lansonli

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值