一、泛型类
class Pair1[T,S](val first:T , val seconds:S) {
override def toString():String = first + "," + seconds
def getMiddle[T](a:Array[T]):T = a(a.length/2)
}
二、上界 <: (T为Comparable的子类型)
class Pair2[T <: Comparable[T]](val first:T,val second:T) {
def smaller:T = if (first.compareTo(second)<=0) first else second
}
三、下界 >:(R是T的父类)
class Pair3[T](val first:T,val second:T) {
def replaceFirst[R >: T](newFirst:R) = new Pair3(newFirst,second)
override def toString():String = first + "," + second
}
四、视图界定 <% T能够隐式转换成Ordered[T]
class Pair4[T <% Ordered[T]](val first:T,val second:T) {
def smaller:T = if (first <= second) first else second
}
五、上下文界定 T:M[T] 存在一个M[T]的隐式值
class Pair5[T:Ordering](val first:T,val second:T) {
def smaller(implicit ord:Ordering[T]) = if (ord.compare(first,second)<0) first else second
}
六、逆变、协变
/**
* 协变(+T): Student是Person的子类型,那么Pair6[Student]也是Pair6[Person]的子类型
* 逆变(-T): Student是Person的子类型,那么Pair7[Student]就是Pair7[Person]的父类型
*/
class Pair6[+T](first:T,second:T)
class Link[+T](val head:T,val tail:Link[T])
//逆变
class Pair7[-T](first:T, second:T)
class Animal{}
class Bird extends Animal{}
class Consumer[T](t: T){
// def get(): T = t
def use(t:T) = {}
}
class Consumer1[+T](t: T){
/**
* 方法的返回值是协变的位置，方法的参数是逆变的位置
* covariant(协变) type T occurs in contravariant(逆变) position in type T of value t
* covariant(协变) type T occurs in contravariant position in type <: T of type U
*/
def get(): T = t
// def use(t:T) = {}
def use[U>:T](t:U) = {}
}
class Consumer2[-T](t: T){
// def get[U<:T](): U = U
// def use(t:T) = {}
}
class Consumer3[-S,+T]() {
// def m1[U >: T](u: U): T = {new T} //协变，下界
// def m2[U <: S](s: S): U = {new U} //逆变，上界
}
七、类型约束
/**
* 类型约束
* T=:=U(T是否=U),T<:<U(T是否为U的子类型),T<%<U(T是否隐式转换为U)
* 在特定条件下(具体方法) 进行类型检测
* Pair[File] 可以构造出,但是使用smaller方法的时候,就会报错.
*/
class Pair8[T](val first:T,val second:T) {
def smaller(implicit ev:T <:<Ordered[T]) = if (first<second) first else second
}
八、定义类和伴生对象
/**
* 主构造器在类名后,参数会被声明字段,若参数没有使用var或者val声明，则会被声明称私有字段
*/
case class Person(val id:String, var name:String,val age:Int){
private val date = "2016-10-20"
// private[this] val: Int = .. ????
override def toString = id+","+name+","+age+","+date
}
object Person{
/* 隐式对象
* 执行过程检查当前作用是否有 implicit object 限定的 类型为 Ordering 的对象，如有，则选取此对象
*/
implicit object PersonOrdering extends Ordering[Person] {
override def compare(x: Person, y: Person) = (x.id==y.id) match {
case false => x.id.compareTo(y.id)
case _ => x.name.compareTo(y.name)
}
}
/* 隐式类
* 当 1.add（2） 时，scala 编译器不会立马报错，而检查当前作用域有没有 用implicit 修饰的，
* 同时可以将Int作为参数的构造器，并且具有方法add的类，经过查找 发现 Calculate 符合要求
*/
implicit class Calculate(x:Int) {
def add(second:Int) = x + second
}
}
九、私有字段(快学scala)
class Counter {
private var value = 0 //在其他地方不能访问;
private[this] var my = 0 //
def increment = value += 1
def increment(n:Int) = my += n
//能在Counter类方法中 访问Counter对象的私有字段
def isLess(other:Counter) = value<other.value
// def isMore(other:Counter) = my<other.my //errors
}
十、封闭类
/**
*
* 定义类型为sealed(封闭类)允许编译器进行彻底的分析(这是针对模式匹配的，参考Programming in Scala)
* 因为构造器将不能从外部源文件中添加
*/
sealed trait Tree[T]
case class Node[T](left: Tree[T], right: Tree[T]) extends Tree[T]
case class Leaf[T](value: T) extends Tree[T]
十一、模式匹配
def findMin[T <: Ordered[T]](tree: Tree[T]):T = tree match {
case Node(left, right) => Seq(findMin(left), findMin(right)).min
case Leaf(value) => value
}
def suffix(i: Int) = i match {
case 1 => "st"
case 2 => "nd"
case 3 => "rd"
case _ => "th"
}
var opt: Option[String] = None
opt = Some("foobar")
opt match {
case Some(value) => // operate(value)
case None => // defaultAction()
}
//使用模式匹配实现类型转换
obj match {
case str: String => ...
case addr: SocketAddress => ...
}
//模式匹配在和解构(destructuring)联合使用时效果最好
animal match {
case Dog(breed) => "dog (%s)".format(breed)
case other => other.species
}
//14.1 better than switch
var ch = '9'
var sign = ch match {
case '+' => 1
case '-' => -1
case _ => 0
}
// 14.2 boolean condition
var digit = 0
ch match {
case '+' => sign = 1
case '-' => sign = -1
case _ if Character.isDigit(ch) => digit = Character.digit(ch, 10)
case _ => sign = 0
}
val obj:Any = BigInt(100)
val result = obj match {
case x:Int => x
case s:String => Integer.parseInt(s)
case _:BigInt => Int.MaxValue
case _ => 0
}
val arr = Array(0,1)
val arr_result = arr match {
case Array(0) => "0"
case Array(x,y) => x+" "+y
case Array(0,_*) => 0 + " ..."
}
