Scala 自学笔记3_特质
1、文件和正则表达式
读取行
import scala.io.Source
val source = Source.fromFile("myfile.txt","UTF-8") //第一个参数可以是字符串或是java.io.File
// 如果文件使用的是当前平台缺省的字符编码，则可以略去第二个字符串编码参数
val lineIterator = source.getLines //返回一个迭代器
for(l <- lineIterator) println(l)
val lines = source.getLines.toArray // 将行放到数组或数组缓冲中
val contents = source.mkString //整个文件读取成一个字符串。
注意：用完Source对象，需要close
读取字符
可以直接把Source对象当做迭代器，因为Source类扩展自Iterator[Char] for( c <- source) println(c)
val tokens = source.mkString.split("\\S+")
如果文件中都是浮点数，可以转换
val numbers = for(w <- tokens) yield w.toDouble
val numbers = tokens.map(_.toDouble)
从控制台读取数字
println("How old are you ?")
val age = readInt() // 或者使用readDouble或readLong
注：这些方法假定下一行输入是数字，且前后无空格，否则报错NumberFormatException
从URL或其他源读取
val source1 = Source.fromURL("http://baidu.com","UTF-8")
val source2 = Source.fromString("Hello, World!")
val source = Source.stdin
读取二进制文件
Scala没有提供读取二进制文件的方法，需要用Java val file = new File(filename); val in = new FileInputStream(file) val bytes = new Array[Byte](file.length.toInt) in.read(bytes) in.close()
写入文本文件
需要用Java
val out = new PrintWriter("numbers.txt")
for (i <- 1to 100) out.println(i)
out.close()
例外：当传递数字给pintf,需要 将它转换为AnyRef:
out.printf("%6d %10.2f", quantity.asInstanceOf[AnyRef], price.asInstanceOf[AnyRef])
为了避免麻烦，也可以使用String类的format方法：
out.print("%6d %10.2f".format(quantity, price))
注意:Console类的printf没有这个问题
printf("%6d %10.2f", quantity, price)
import java.io.File
def subdirs(dir: File): Iterator[File] = {
val children = dir.listFiles.filter(_.isDirectory)
children.toIterator ++ children.toIterator.flatMap(subdirs _)
}
for (d <- subdirs(dir)) 处理 d
序列化
Java和Scala 中 声明一个可被序列化的类。
Java:
public class Person implements java.io.Serializable{
private static final long serialVersionUID = 42L;
}
Scala:
@SerialVersionUID(42L) class Persion extends Serializable
//Serializable特质定义在scala包，因此不需要显式引入。
注：如果能接受缺省的ID，可略去@SerialVersionnUID注解。
可以按照常规的方式对对象进行序列化和反序列化
val fred = new Persion(...)
import java.io._
val out = new ObjectOutputStream(new FileOutputStream("/temp/test.obj"))
out.writeObject(fred)
out.close()
val in = new ObjectInputStream(new FileInputStream("/tmp/test.obj"))
val savedFred = in.readObject().asInstanceOf[Person]
Scala集合类都是可序列化的，因此可以把他们用作可序列化类的成员：
class Person extends Serializable{
private val friends = new ArrayBuffer[Person] //OK --- ArrayBuffer 是可序列化的
}
import sys.proccess._
"ls -al .."!
sys.process 包含一个从字符串到ProcessBuilder对象的隐式转换。 ! 操作符执行的就是 这个ProcessBuilder对象。
! 操作符返回的结果是 被执行程序的返回值：成功是0，否则是非0
如果用 !! 而不是 ! ， 输出会以字符串的形式返回:
val result = "ls -al .."!!
"ls -all .."#| "grep sec" ! // 管道
"ls -all .." #> new File("output.txt") // 重定向
"ls -all .." #>> new File("output.txt") //追加到文件末尾 而不是 从头覆盖
"grep sec" #< new File("output.txt") ! // 把某个文件的内容作为输入
"greg Scala" #< new URL("http://xxx/index.html") ! //从URL重定向输入
如果需要在调用命令时，设置环境变量和进入不同的目录，可以用Process对象的apply方法来构造ProcessBuilder
val p = Process(cmd, new File(dir), ("LANG", "en_UR")) // 分别为 命令，目录，变量（一串对偶）
"echo 42" #| p !
正则表达式
val numPattern = "[0-9]+".r // 用String类的r方法，构建scala.util.matching.Regex
val wsPattern = """\s+[0-9]+\s""".r // 用“原始”字符串语法"""..."""，来规避反斜杠或引号的转义
for(matchString <- numPattern.findAllIn("99 bottles, 98 bottles")) // findAllIn方法返回遍历所有匹配项的迭代器。
处理 matchString
val matches = numPattern.findAllIn("99 bottles, 98 bottles").toArray // Array(99, 98), 把迭代器转换为数组。
val ml = wsPattern.findFirstIn("99 bottles, 98 bottles") // findFirstIn 返回首个匹配项, 返回的是Some("98")，一个Option[String]
numPattern.findPrefixOf("99 bottles, 98 bottles') // finPrefixOf开始部分匹配 , Some(98)
wsPattern.findPrefixOf("99 bottles, 98 bottles")// None
numPattern.replaceFirstIn("99 bottles, 98 bottles", "XX") ""XX bottles, 98 bottles"", 首个匹配替换
numPattern.replaceAllIn("99 bottles, 98 bottles", "XX") ""XX bottles, XX bottles""， 全部匹配替换
表达式分组
val numitemPattern = "([0-9]+) ([a-z]+)".r
val numitemPattern(num, item) = "99 bottles" // num 设为99， item 设为 bottles
for(numitemPattern(num, item) <- numitemPattern.findAllIn("99 bottles, 98 bottles"))
处理 num 和 item
2、特质
当接口使用的特质
trait Logger{
def log(msg: String) // 特质中未被实现的方法皆是抽象方法
}
class ConsoleLogger extends Logger{ // 用extends， 而不是implements
def log(msg: String) {println(msg)} //无需override
}
class ConsoleLogger extends Logger with Cloneable with Serializable // 多个特质用 with 关键字
和Java类似，Scala只能有一个超类，但可以有多个特质。
带有具体实现的特质
trait ConsoleLogger{
def log(msg: String) {println(msg)}
}
class SaveAccount extends Account with ConsoleLogger{
def withdraw(amount: Double){
if(amount > balancce) log("Insufficient funds")
else balance -= amount
}
}
与Java接口不同，特质 可以有具体方法
trait Logged{
def log(msg: String) {} //空实现
}
class SavingsAccount extends Account with Logged{
def withdraw(amount : Double){
if(amount > balance) log("Insufficient Funds")
}
}
这里的log 什么都不会做
trait ConsoleLogger extends Logged{
override def log(msg : String) {println(msg)}
}
val acct = new SavingAccount with ConsoleLogger
这里的acct 对象 在调用log方法时， ConsoleLogger特质的log方法就会被执行。
叠加调用的特质
trait TimestampLogger extends Logged{
override def log(msg:String){
super.log(new java.util.Data() + " " + 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) + "...")
}
}
}
特质的super.log方法，并不像类一样调用父类的log方法，
super.log调用的是特质层级中的下一个特质，具体哪一个，是根据特质添加顺序决定，由后向前执行。
val acct1 = new SavingAccount with ConsoleLogger with TimestampLogger with ShortLogger // Sun Feb 16 10:55:45 ICT 2015 Insttiecient
val acct1 = new SavingAccount with ConsoleLogger with ShortLogger with TimestampLogger // Sun Feb 16 1...
根据特质的顺序，执行super方法，
如果需要控制具体哪一特质的方法，则可以使用
super[ConsoleLogger].log(...)，这里给出的类必须是直接超类型，无法使用继承层级中更远的特质或类
特质中重写抽象方法
trait Logger{
def log(msg: String) // 与上面空实现不同，这里是个抽象方法
}
trait TimestampLogger extends Logger{
abstract override def log(msg:String){
super.log(...) //这里的super.log 是抽象的，Logger.log方法没有实现，无法知道哪个log方法最终被调用，取决于特质的混入顺序。
}
}<pre name="code" class="java">//因为调用了父特质的抽象方法，Scala认为TimestampLogger依旧是抽象的，需要混入一个具体的log方法，这里必须 给出 abstract override。
当做富接口使用它的特质
trait Logger{
def log(msg: String)
def info(msg: String){ log("INFO" + msg) }
def warn(msg: String){log("WARN" + msg)}
def sevre(msg: String){log("SEVERE:" + msg)}
}// 把抽象和具体方法结合在一起
class SavingAcccount extends Account with Logger{
def withdraw(amount : Double){
if(amount > balance ) server("Insufficient funds")
else ...
}
...
override def log(msg: String) {pirntln(msg)}
}
在Scala中 这样在特质中使用具体和抽象方法十分普遍。
在Java中， 就需要声明一个接口和一个额外的扩展该接口的类（一般是抽象类）。
特质中的具体字段
trait ShortLogger extends Logged{
val maxLength = 15 // 具体字段，不给初始值即为抽象字段
}
当有类混入这个特质时， 这个类会自动获得一个maxLength字段，这个字段不是被继承的，而是 简单地被加入到了 子类中。（这是由于JVM，一个类智能扩展一个超类）
特质中的抽象字段
trait ShortLogger extends Logged{
val maxLength : Int //抽象字段
override def (msg :String){
super.log{
if(msg.length <= maxLength) msg else ... // 在这个实现中 使用了 抽象字段 maxLength
}
}
}
1、在具体的类中，混入该特质时，必须提供maxLength字段
class SavingsAccount extends Account with ConsoleLogger with ShortLogger{
val maxLength = 20 // 无需override
}//<span style="font-family: Arial, Helvetica, sans-serif;">这里要求在特质的构造中没有用到这个值，否则需要提前声明或用懒值，详细看下面 ”初始化特质中的字段“</span>
2、在定义时未用，但在使用时混入该特质 构造对象时
class SavingAccount extends with Logged{...} //定义时，使用了 父特质
val acct = new SavingsAccount with ConsoleLogger with ShortLogger{
val maxLength = 20 // 增加的灵活性，非常便利
}
特质构造顺序
和类一样，特质也可以有构造器，由字段初始化和其他特质体中的语句构成
trati FileLogger extends Logger{
val out = new PrintWriter("app.log")
out.printlnn("#" + new Date().toString)
def log(msg: String) {out. println(msg); out.flush()}
}
以上语句在任何混入该特质的对象在构造时都会被执行。
类的构造器以如下顺序执行：
1、首先调用超类的构造器
2、特质构造器在超类构造器之后，类构造器之前执行
3、特质由左到右被构造
4、每个特质中，父特质先被构造
5、如果多个特质共有一个特质，而父特质已被构造，则不会在此构造
6、所有特质构造完毕，子类被构造。
例：
class SavingsAccount extends Account with FileLogger with ShortLogger
1、Account（超类）
2、Logger（第一个特质的父特质）
3、FileLogger（第一个特质）
4、ShortLogger（第二个特质，父特质已被构造）
5、SavingsAccount（类）
初始化特质中的字段
特质不能有构造参数， 每个特质都有一个无参的构造器
特质与类之间唯一的技术差别，就是缺少构造器参数
所以我们只能通过其他方式来初始化特质中的字段
trait FileLogger extends Logger{
val filename: String
val out = new PrintStream(filename)
def log(msg:String) {out.prinltn(msg);out.flush()}
}
val acct = new SavingsAccount with FileLogger{ val filname = "myapp.log"} // 这样行不通
这里和上一节类似，不过这里的问题出在构造顺序上，FileLogger先于子类构造执行，这里的子类并不那么容易看清楚
new语句构造的其实是一个扩展自SavingsAccount(超类)并混入了FileLogger特质的匿名类的实例。
filenam的初始化只发生在这个匿名子类中，但在轮到子类之前，FileLogger的构造器就抛出了空指针异常。
解决方法：
1、提前定义
val acct = new { // new 之后的提前定义块
val filename = "myapp.log" // 提前定义发生在常规的构造序列之前
} with SavingsAccount with FileLogger
如果要在类中做同样的事情，语法如此：
class SavingsAccount extends { // extends 后是提前定义块
val filename = "savings.log"
}with Account with FileLogger{
// SavingAcccount 的实现
}
2、在FileLogger构造器中使用懒值
trait FileLogger extends Logger{
val filename: String
lazy val out = new printStream(filename)
def log(msg : String){ out.println(msg)}
}//由于懒值在每次使用前都会检查是否已经初始化，所有不高效。
扩展类的特质
特质扩展特质，由特质组成的继承层级很常见
不常见的一种用法是， 特质也可以扩展类
这个类将会自动成为所有混入该特质的超类。
trait LoggedException extends Exception with Logged{
def log() { log( getMessage())} // log方法调用了从Exception 超类继承下来的getMessage()方法
}
class UnhappyException extends LoggedExxception{ // Exception自动成为我们类的超类
override def getMessage() = "arggh!"
}
class UnhappyException extends IOExcpetion with LoggedExecption //ok , IOException是 Exception的子类
class UnhappyFrame extends JFrame with LoggedException //错误，不相关的超类
自身类型
this: 类型 =>
trait LoggedException extends Logged {
this: Exception =>
def log(){ log(getMessage()) }
}//该特质并不扩展Exception类，而是有一个自身类型，这以为这它只能被混入Exception的子类。
在特质方法中，我们可以调用该自身类型的任何方法，比如getMessage()，因为this必定是一个Exception。
val f = new JFrame with LoggedException // 错误，JFrame不是Exception 的子类型
在某些情况小夏自身类型 比 超类型版的 特质更灵活。 自身类型可以解决特质间的循环依赖。
自身类型也同样可以处理结构类型（structural type） -----这种类型只给出类必须拥有的方法，而不是类的名称。
trait LoggedException extends Logged{
this:{ def getMessage(): String } =>
def log() {log(getMessage())}
} 这个特质可以被混入任何拥有getMessage方法的类。