一、为什么没有多重继承

c++允许多重继承

Java不允许多重继承,类只能继承一个超类,可以实现任意数量的接口。

如何继承这两个抽象基类?

Scala提供“特质”而非接口;特质可以同时抽象方法和具体方法。类可以实现多个特质。

二、当做接口使用的特质

  trait Logger{
def log(msg: String)
} class ConsoleLogger extends Logger{ //使用 extends 不能使用 implements def log(msg: String): Unit ={ // 不需要使用override
println(msg)
}
}

三、带有具体实现的特质

  trait Logger{
def log(msg: String){println(msg)}
} class SavingAccount extends Logger{
def display(msg: String): Unit ={
log(msg)
}
} val v = new SavingAccount()
v.display("Hello")

注:特质发生变化,所有混入特质的类都需要重新编译。

四、带有特质的对象

  trait Logged{
def log(msg: String){} //特质,方法是个空实现
} trait ConsoleLogger extends Logged{
override def log(msg: String) {println(msg)}
} class SavingAccount extends Logged{ //类继承特质,方法的实现结果为空
def display(msg:String){log(msg)
}
} val s = new SavingAccount() //构造对象,结果为空
s.display("Hello") val s1 = new SavingAccount() with ConsoleLogger //在构造对象的时候,加入特质,结果为 Hello
s1.display("Hello")

五、叠加在一起的特质

trait Logged{
def log(msg: String){}
} trait ConsoleLogger extends Logged{
override def log(msg: String) {println(msg)}
} trait TimestampLogger extends Logged{
override def log(msg: String){
super.log(new java.util.Date() + " " + msg)
}
} trait ShortLogger extends Logged{
val maxLength = 15
override def log(msg: String){
super.log(
if(msg.length <= maxLength) msg else msg.substring(0, maxLength-3) + "..."
)
}
} class SavingAccount extends Logged {
def display(msg: String) {
log(msg)
}
} val s = new SavingAccount with ConsoleLogger with TimestampLogger with ShortLogger //ShortLogger的log方法先执行,然后是 TimestampLogger
s.display("Hello") val s1 = new SavingAccount with ConsoleLogger with ShortLogger with TimestampLogger //TimeStampLogger的方法先执行,然后是 ShortLogger
s1.display("Hello")

结果:

Wed Aug 31 23:27:53 CST 2016 Hello
Wed Aug 31 2...

六、在特质中重写抽象方法

    trait Logged{
def log(msg: String)
} trait ConsoleLogger extends Logged{
override def log(msg: String) {println(msg)}
}
trait TimestampLogger extends Logged{
abstract override def log(msg: String){ //继承抽象方法,需要使用abstract关键字,对抽象方法进行重写
super.log(new java.util.Date() + " " + msg)
}
} class SavingAccount extends ConsoleLogger {
def display(msg: String) {
log(msg)
}
} val s = new SavingAccount with TimestampLogger
s.display("Hello")

结果:

Wed Aug 31 23:51:40 CST 2016 Hello

七、当做富接口使用的特质

    trait Logged{                           // 特质将抽象方法,和具体方法结合在一起
def log(msg: String)
def info(msg: String){log(msg)}
def warn(msg: String){log(msg)}
} trait ConsoleLogger extends Logged{
override def log(msg: String) {println(msg)}
}
trait TimestampLogger extends Logged{
abstract override def log(msg: String){ //继承抽象方法,需要使用abstract关键字,对抽象方法进行重写
super.log(new java.util.Date() + " " + msg)
}
} class SavingAccount extends ConsoleLogger {
def display(msg: String) {
info(msg)
}
} val s = new SavingAccount with TimestampLogger
s.display("Hello")

结果:

Thu Sep 01 09:38:54 CST 2016 Hello

八、特质中的具体字段

在子类中添加特质,特质中的字段就相当于子类中的字段

九、特质中的抽象字段

特质中的抽象字段,在子类的具体实现中必须要被重写

    trait Logged{                           // 特质将抽象方法,和具体方法结合在一起
val maxLength: Int // 抽象字段
def log(msg: String)
def info(msg: String){log(msg)}
def warn(msg: String){log(msg)}
} trait ConsoleLogger extends Logged{
override def log(msg: String) {println(msg)}
}
trait TimestampLogger extends Logged{
abstract override def log(msg: String){ //继承抽象方法,需要使用abstract关键字,对抽象方法进行重写
super.log(new java.util.Date() + " " + msg)
}
} class SavingAccount(val maxLength: Int) extends ConsoleLogger { //抽象字段当做参数传递
//val maxLength = 20 //抽象字段在类中被重写
def display(msg: String) {
info(msg)
info(maxLength.toString)
}
} val s = new SavingAccount(20) with TimestampLogger //传递参数
s.display("Hello")

结果:

Thu Sep 01 10:05:55 CST 2016 Hello
Thu Sep 01 10:05:55 CST 2016 20

十、特质构造顺序

1、首先调用超类的构造器

2、然后调用特质构造器,特质构造器在超类构造器之后,类构造器之前

3、特质由左到右被构造

4、在每个特质当中,父特质先被构造

5、如果多个特质公用一个父特质,而那个父特质已经被构造过了,则不会再被构造

6、所有特质构造完毕,子类被构造

例子:

class SavingAccount extends Account with FileLogger with ShortLogger

构造器执行顺序:

1、Account(超类)

2、Logger(第一个特质的父特质)

3、FileLogger(第一个特质)

4、ShortLogger(第二个特质)

5、SavingAccount(类)

特质方法Super被解析的顺序 从右向左

ShortLogger(super)->FileLogger(super)->Logger

  trait Logged{
def log(msg: String){}
} trait ConsoleLogger extends Logged{
override def log(msg: String) {println(msg)}
} trait TimestampLogger extends Logged{
override def log(msg: String){
println("This is TimestampLogger")
super.log(new java.util.Date() + " " + msg)
}
} trait ShortLogger extends Logged{
val maxLength = 15
override def log(msg: String){
println("This is ShortLogger")
super.log(
if(msg.length <= maxLength) msg else msg.substring(0, maxLength-3) + "..."
)
}
} class SavingAccount extends Logged {
def display(msg: String) {
log(msg)
}
} val s = new SavingAccount with ConsoleLogger with TimestampLogger with ShortLogger
s.display("Hello") val s1 = new SavingAccount with ConsoleLogger with ShortLogger with TimestampLogger
s1.display("Hello")

结果:

This is ShortLogger
This is TimestampLogger
Thu Sep 01 13:55:33 CST 2016 Hello
This is TimestampLogger
This is ShortLogger
Thu Sep 01 1...

十一、初始化特质中的字段

特质中不能使用构造参数

要想初始化特质中的字段,可使用如下方式:

1、提前定义,在特质的构造函数之前定义

  trait Logger{
def log(msg: String){}
} trait FileLogger extends Logger{
val filename: String
val out = new PrintWriter(filename)
override def log(msg: String) {
out.println(msg)
out.flush()
}
} class SavingAccount extends Logger{
def display(msg: String): Unit ={
log(msg)
}
}//val c = new SavingAccount with FileLogger{ val filename="mylog.txt" } //构造器运行在 FileLogger构造器之后,所以不会运行成功
val c = new {val filename = "mylog.txt"} with SavingAccount with FileLogger //这里使用了提前定义,可以正确执行 c.display("hello11")

2、使用lazy值

  trait Logger{
def log(msg: String){}
} trait FileLogger extends Logger{
val filename: String
lazy val out = new PrintWriter(filename) //使用懒值 out 在使用时,才会初始化,那时filename值已经被正确设置了
override def log(msg: String) {
out.println(msg)
out.flush()
}
} class SavingAccount extends Logger{
def display(msg: String): Unit ={
log(msg)
}
}//val c = new SavingAccount with FileLogger{ val filename="mylog.txt" } //构造器运行在 FileLogger构造器之后,所以不会运行成功
//val c = new {val filename = "mylog.txt"} with SavingAccount with FileLogger //这里使用了提前定义,可以正确执行
val c = new SavingAccount with FileLogger { val filename="mylog.txt" } c.display("hello world")

懒值在每次使用前都会检查是否已经初始化,用起来并不是那么高效

3、使用类主构造器传参

  trait Logger{
def log(msg: String){}
} trait FileLogger extends Logger{
val filename: String
//lazy val out = new PrintWriter(filename) //使用懒值 out 在使用时,才会初始化,那时filename值已经被正确设置了
val out = new PrintWriter(filename)
override def log(msg: String) {
out.println(msg)
out.flush()
}
} // class SavingAccount extends Logger{
// def display(msg: String): Unit ={
// log(msg)
// }
// } class SavingAccount(val filename: String) extends Logger{
def display(msg: String): Unit ={
log(msg)
}
} //val c = new SavingAccount with FileLogger{ val filename="mylog.txt" } //构造器运行在 FileLogger构造器之后,所以不会运行成功
//val c = new {val filename = "mylog.txt"} with SavingAccount with FileLogger //这里使用了提前定义,可以正确执行
//val c = new SavingAccount with FileLogger { val filename="mylog.txt" }
val c = new SavingAccount("mylog.txt") with FileLogger c.display("hello world 111")

十二、扩展类的特质

特质可以扩展另一个特质,特质也可以扩展类

类扩展了特质,特质扩展了类,特质的超类成为我们类的超类;

如果类扩展了另一个类,只要那个类是特质超类的子类就可以。

如果扩展多个类,且是不相干的,类不能有多个超类

  trait Logged{
def log(msg: String){}
} trait LoggedException extends Exception with Logged{ //特质扩展超类
def log() {log(getMessage())}
} class UnhappyException extends LoggedException{ //类扩展特质,特质的超类Exception 也成为了类UnHappyException的超类
override def getMessage() = "aaa"
} class UnhappyException extends IOException with LoggedException //可以扩展 IOException是 Exception的子类 class UnhappyException extends JFrame with LoggedException // JFrame 和 Exception 没继承关系 不能扩展

十三、自身类型

this : Exception =>

    trait Logged{
def log(msg: String){}
} trait LoggedException extends Logged{ //特质扩展超类
this: Exception => //自身类型 自身类型为Exception,它只能被混入Exception的子类
def log() {log(getMessage())}
} val f = new JFrame with LoggedException //错误 JFrame不是 Exception的子类型,而Exception是LoggedException的自身类型

结构类型:

  trait Logged{
def log(msg: String){}
} trait LoggedException extends Logged{ //特质扩展超类
this: {def getMessage():String} => //自身类型(结构类型) 这个特质可以被混入任何拥有getMessage方法的类
def log() {log(getMessage())}
}

十四、背后发生了什么

参考《快学Scala》

Scala--特质的更多相关文章

  1. scala特质

    package com.ming.test /** * scala 特质,类似与java接口,但是比java接口强大,可以有实现方法,定义字段之类的 */ /** * 定义一个日志的特质 */ tra ...

  2. Scala 特质全面解析

    要点如下: Scala中类只能继承一个超类, 可以扩展任意数量的特质 特质可以要求实现它们的类具备特定的字段, 方法和超类 与Java接口不同, Scala特质可以提供方法和字段的实现 当将多个特质叠 ...

  3. scala akka 修炼之路5(scala特质应用场景分析)

    scala中特质定义:包括一些字段,行为(方法/函数/动作)和一些未实现的功能接口的集合,能够方便的实现扩展或混入到已有类或抽象类中. scala中特质(trait)是一个非常实用的特性,在程序设计中 ...

  4. 8.scala:特质

    版权申明:转载请注明出处.文章来源:http://bigdataer.net/?p=317 总体来说,scala中的特质类似于Java中的接口,但是有别于接口的是特质中既可以有实现方法也可以有抽象方法 ...

  5. scala 特质的应用

    一.为类提供可以堆叠的改变 package com.jason.qianfeng trait Loggertest { def logger(msg: String) } trait ConsoleL ...

  6. scala学习笔记——特质

    一个类扩展自一个或多个特质,以便使用这些特质提供的服务.特质可能会要求使用它的类支持某个特定的特性.不过和java不同,Scala特质可以给出这些特性的缺省实现. 特质的特性: 类可以实现任意数量的特 ...

  7. 快学Scala之特质

    一个Scala类可以继承多个特质(trait), 特质可能会要求使用它们的类支持某个特定特性, 与Java接口不同, Scala特质可以给出这些特质的缺省实现. 要点如下: Scala中类只能继承一个 ...

  8. Scala入门2(特质与叠加在一起的特质)

    一.介绍 参考http://luchunli.blog.51cto.com/2368057/1705025 我们知道,如果几个类有某些共通的方法或者字段,那么从它们多重继承时,就会出现麻烦.所以Jav ...

  9. 快学Scala习题解答—第十章 特质

    10 特质 10.1 java.awt.Rectangle类有两个非常实用的方法translate和grow,但可惜的是像java.awt.geom.Ellipse2D这种类没有. 在Scala中,你 ...

  10. Scala学习十——特质

    一.本章要点 类可以实现任意数量的特质 特质可以要求实现它们的类具备特定的字段,方法或超类 和Java接口不同,Scala特质可以提供方法和字段实现 当你将多个特质叠加在一起时,顺序很重要——其方法先 ...

随机推荐

  1. 【代码笔记】iOS-自定义switch

    一,效果图. 二,工程图. 三,代码. ViewController.h #import <UIKit/UIKit.h> #import "CustomSwitch.h" ...

  2. Django中Ajax提交数据的CSRF问题

    错误信息: Forbidden (CSRF token missing or incorrect.): 什么是CSRF: django为用户实现防止跨站请求伪造的功能,通过中间件 django.mid ...

  3. CentOS7添加入windows2008的AD域

    采用域控对用户权限进行限制的时候,经常会出现需要将linux加入windows域,毕竟windows的AD域超级强大.用户名可以由windows进行统一管理,方便办公使用.下面简单介绍如何进行配置. ...

  4. Android JNI的使用方法

    1.JNI是什么 JNI是Java Native Interface的缩写,它提供若干的API实现Java与其他语言之间的通信.而Android Framework由基于Java语言的的Java层与基 ...

  5. linux 查找匹配文件中包含指定字符的 前五行,这里是指所有匹配的前五行

    最近被问到 一个关于查找匹配字符的信息显示问题: 系统/etc/sysctl.conf文件会定义系统内核的一些配置,请查找和net有关的信息,并只打印前面5行信息. 解决方式大概试两种写法均可: 1. ...

  6. Python+Selenium笔记(十一):配置selenium Grid

    (一) 前言 Selenium Grid可以将测试分布在若干个物理或虚拟机器上,从而实现分布方式或并行方式执行测试. 这个链接是官方的相关说明. https://github.com/Selenium ...

  7. Pytest+Allure环境的搭建

    参考博客 测试报告解释 pytest+allurre进阶 1. pytest的安装: 1.1. windows下: pip install pytest 1.2. linux下: pip instal ...

  8. 70部MAYA灯光材质渲染教程合集

    MAYA灯光材质渲染教程合集 教程格式:MP4和flv 两种格式 使用版本:教程不是一年出的教程,各个版本都有 (教程软件为英文版) 清晰度:可以看清软件上的文字 语言:部分中文字幕,其他英文(通过看 ...

  9. JSON教程基础

    一.基础简介 二.JSON 语法 三.JSON 使用 一.基础简介 1.JSON:JavaScript 对象表示法(JavaScript Object Notation). JSON 是存储和交换文本 ...

  10. python常用模块之string

    python常用模块string模块,该模块可以帮我们获取字母.数字.特殊符号. import string #打印所有的小写字母 print(string.ascii_lowercase) #打印所 ...