Scala学习第五天

流类型
-------------------------------------------------------
流是一个尾部被懒计算的的不可变列表；

---------------

def numsFrom(n: Int): Stream[BigInt] = { n #:: numsFrom(n+1); };

懒视图
---------------
通过集合方法view也可以生成一个方法总是被懒执行的新集合；

模式匹配
-----------------------------------------------

val ch = '+';
ch match { //不会存在进入下一分支的问题
case '+' => sign = 1;
case '-' => sign = -1;
case _   => sign = 0; //与default等效
}

在match表达式中使用任何类型，而不仅仅是数字

color match {
case Color.RED => println("red");
case Color.GREEN => println("green");
case Color.BLACK => println("black");
}

给模式添加守卫
---------------------

var sign = 0;
ch match {
case '+' => sign = 1;
case '-' => sign = -1;
case _ if Character.isDigit(ch) => sign = Character.digit(ch, 10); // case _ 添加守卫，判断是否是数字字符
case _ => sign = 0;
}

模式中的变量
--------------------------------------
如果尾随case的是一个变量名，那么匹配的表达式会被赋值给该变量；

ch match {
case '+' => sign = 1;
case '-' => sign = -1;
case  i => i += 1; //非+或-符号的字符将会被赋值给变量i;
}

Scala中常量和变量的规则是：变量必须以小写字母开头，如果定义小写字母开头的常量，
则在反引号中使用； `pathSeperator`

类型模式
------------------------------------
可以对表达式的类型进行匹配；
-------------
obj match {
case x: Int => x
case s: String => Integer.parseInt(s)
case _: BigInt => Int.MaxValue
case _ => 0
}

匹配数组、列表和元组
-----------------------
arr match {
case Array(0) => "0" //匹配只包含一个元素0的数组
case Array(x, y) = > x + "" + y //匹配只有两个元素的数组
case Array(0, _*) => "0..." //匹配以0开始的任何长度的数组
case _ => "anyelse array!" //任何数组
}

abstract class Amount;
case class Dollar(v: Double) extends Amount;
case class Currency(v: Double, unit: String) extends Amount;
case object Nothing extends Amount;

val  a = new Dollar(1.2);
val (x,y,z) = (0.0, 0.0, 0.0);
a match {
case Dollar(x) => println("1");
case Currency(y, z) => println("2");
case Nothing() => println("3");
}

密封类
---------------------------------------------------
关键字  sealed;
密封类的子类必须与在密封类相同的文件中定义。

Option类型
---------------------------------------------------
Option类型用样例类来表示那些可能存在、也可能不存在的值；
样例子类Some包装某个值；样例对象None表示没有值；
Map类的get方法返回一个Option; 
getOrElse()方法返回一个默认值；

偏函数
----------------------------------------------------
被包含在花括号内的一组case语句是一个偏函数--一个并非对所有输入值都有定义的函数；
它是PartialFunction[A,B]类的一个实例；
val f: PartialFunction[Int, Char] = { case 1 => '1'; case 2 => '2'}
f(1) //返回 ‘1’
f.isDefinedAt(0) //返回false;
f(0); //抛出MatchError错误；
某些函数接收PartialFunction作为参数； 如collect方法；

注解
----------------------------------------------------------------------
注解是插入在代码中由工具对他们进行处理的标签

类型参数
----------------------------------------------------------------------
在Scala中使用方括号来定义类型参数
泛型类
class Part[T, S](val first: T, val second: S); //类型参数放置在类名后

泛型函数
def getMiddle[T](a: Array[T]) = a(a.length / 2); //类型参数在方法名后；
类型变量界定
class Pair[T](val first: T, val second: T) {
def smaller = if(first.compareTo(second) < 0) first else second; //错误

}
这里需要不知道T类型是否包含compareTo方法，解决这个方法就是添加上界
T <: Comparable[T] //类型为子类
class Pair[T <: Comparable[T]](val first: T, val second: T) {
def smaller = if(first.compareTo(second) < 0) first else second; //错误
}
R >: T //下界，R为T的超类型；
视图界定
Scala中Int不是Comparable子类；RichInt实现了Comparable,同时还有
从Int到RichInt的隐式转换，可以使用试图界定
class Part[T <% Comparable[T]]; //<%意味着T隐式的被转换为Comparable;

定义上下界
class obj[T >: Int <: Any]{} //书写个数
class obj[Int <: T <: Any]{}

型变
def makeFriends(p: Pair[Person]);
如果Student是Person的子类，使用Pair[Student]作为类型调用makeFriends()
是错误的，因为Pair[Student]和Pair[Person]之间没有任何关系；
想解决这个关系，必须在定义Pair类时表明这一点
--------------------
class Pair[+T](val first: T, val second: T){ }

高级类型
------------------------------------------------------
单例类型
给定任何引用v，你可以得到类型v.type,可以返回两个值：v和null;
class Document {
def setTittle(title: String): this.type  = {println(title);this} //this.type动态获取返回对象类型
def setAuthor(author: String): this.type = {println(author);this}
}

val doc = new Document();
doc.setAuthor("Lee").setTittle("Scala for Newer");
class Book extends Document {
def addChapter(chapter: String): this.type = { println(chapter); this;}
}
val book = new Book();
book.setTittle("Scala for the Impatient").addChapter("chater1"); // 对象是单例对象

类型投影
class Network {
class Member(val name: String) {
val contacts = new ArrayBuffer[Member];
}
private val members = new ArrayBuffer[Member];
def join(name: String) = {
val m = new Member(name);
members += m;
m;
}
}
这个存在约束，例如
val chatt = new Network();
val face  = new Network();
val tom = chatt.join("tom");
val han = face.join("han");
tom.contacts += han; //错误，如果想松绑这样的约束，
将val contacts = new ArrayBuffer[Member]; 改为val contacts = new ArrayBuffer[Network#Member];