泛型Generic Type
Generic :一般的，普通的；通用的，不专用的；非专用装置的；非特有的
方法或者类可以接受任何类型的参数，参数类型只有在使用的时候或者调用的时候才被确定，类.特质.函数都可以有类型参数。
泛型可以使方法或者类更加通用。
泛型类：
scala> class fruit[A,B](var name:A,var price:B){println(s"I love $name,but $price dolar is too high!")}
defined class fruit
scala> val apple=new fruit[String,Int]("apple",5)
I love apple,but 5 dolar is too high!
apple: fruit[String,Int] = fruit@1e7113f8
scala> val apple=new fruit("apple",5)
I love apple,but 5 dolar is too high!
apple: fruit[String,Int] = fruit@7adf8932
scala> val banana=new fruit[String,String]("banana","five")
I love banana,but five dolar is too high!
banana: fruit[String,String] = fruit@6d4062fd
泛型函数：
scala> def method[T](arr:Array[T]){arr.foreach(println)}
method: [T](arr: Array[T])Unit
scala> method[Int](Array(1,2,3))
1
2
3
scala> method[String](Array("one","two","three"))
one
two
three
scala> method(Array('a','b',1))
97
98
1
scala> method(Array('a','b',"aaa"))
a
b
aaa
----------------------------
scala> 1.compareTo(100)
res8: Int = -1
scala> 1.compareTo(1)
res9: Int = 0
scala> 1.compareTo(-100)
res10: Int = 1
---------------------------------
类型变量界定
Java中, (? extends T), T称为上界, 比较容易理解, 代表T和T的子类, (? supers T), T称为下界
Scala中, 界却用于泛型类中的方法的参数类型上
对类型变量进行限制
scala> def compare[T1](a:T1,b:T1){if(a.compareTo(b)>=0)println(">=") else println("<")}
<console>:11: error: value compareTo is not a member of type parameter T1
def compare[T1](a:T1,b:T1){if(a.compareTo(b)>=0)println(">=") else println("<")}
^
这是错误的，我们并不知道a是否有compareTo方法。
要解决这个问题，我们可以添加一个上界 T <: Comparable[T] :
scala> def compare[T<:Comparable[T]](a:T,b:T){if(a.compareTo(b)>=0)println(">=") else println("<")}
compare: [T <: Comparable[T]](a: T, b: T)Unit
scala> compare[String]("100","50")
<
scala> compare[String]("tdd","mn")
>=
scala> compare[Int](100,50)
<console>:13: error: type arguments [Int] do not conform to method compare's type parameter bounds [T <: Comparable[T]]
compare[Int](100,50)
^
Int不是Comparable[Int]的子类，Scala Int类型没有实现Comparable接口
scala> compare[BigInt](100,50)
>=
scala> class compare[T<:Comparable[T]](a:T,b:T){def smaller()={ if(a.compareTo(b)<0) a else b;}}
defined class compare
scala> val comp=new compare[String]("gg","ss")
comp: compare[String] = compare@706243d4
scala> val comp=new compare[String]("gg","ss")
comp: compare[String] = compare@706243d4
scala> val comp=new compare[BigInt](100,50)
comp: compare[BigInt] = compare@2443ac97
scala> comp.smaller
res33: BigInt = 50
上界：
只允许T的超类U来替换T。 [U >: T]
下界：
只允许T的子类U来替代T。 [U <: T]
视图界定
部分类型不是Comparable[Int]的子类，导致报错，解决方法就是视图界定
<%关系意味着T可以被隐式的转换为Comparable[Int]
scala> class compare[T<%Comparable[T]](a:T,b:T){def smaller()={ if(a.compareTo(b)<0) a else b;}}
defined class compare
scala> val comp=new compare[String]("gg","ss")
comp: compare[String] = compare@1516d85a
scala> comp.smaller
res34: String = gg
scala> val comp=new compare[Int](100,50)
comp: compare[Int] = compare@889cd2f
scala> comp.smaller
res35: Int = 50
上下文界定
上下文界定形式 T:M,其中M是另一个泛型类，它要求必须有一个类型为M[T]的"隐形值"
scala> class pair[AA:Ordering](val f:AA,val s:AA){ def smaller(implicit ord:Ordering[AA])={ if (ord.compare(f,s)<0) f else s;}}
defined class pair
scala> val p1=new pair[BigInt](100,200)
p1: pair[BigInt] = pair@4cea9399
scala> p1.smaller
res164: BigInt = 100
scala> val p1=new pair[BigInt](100,20)
p1: pair[BigInt] = pair@4728b5f5
scala> p1.smaller
res165: BigInt = 20
scala> val p1=new pair(100,20)
p1: pair[Int] = pair@68694894
scala> p1.smaller
res166: Int = 20
scala> val p1=new pair("aa","bb")
p1: pair[String] = pair@be81a18
scala> p1.smaller
res167: String = aa
scala> val p1=new pair("aa",100)
<console>:18: error: No implicit Ordering defined for Any.
val p1=new pair("aa",100)
^
Manifest上下文界定
实例化一个Array[TT]对象，就需要一个Manifest[TT]对象
scala> def makarr[TT:Manifest](f:TT,s:TT)={ val arr=new Array[TT](2);arr(0)=f;arr(1)=s;arr}
makarr: [TT](f: TT, s: TT)(implicit evidence$1: Manifest[TT])Array[TT]
scala> makarr(100,20)
res171: Array[Int] = Array(100, 20)
scala> makarr("ddd",20)
res172: Array[Any] = Array(ddd, 20)
scala> makarr[String]("ddd","dd")
res176: Array[String] = Array(ddd, dd)
多重界定
类型变量可以同时有上界和下界，写法如下：
T<:Upper>:Lower
可以多个视图界定
T<%Compareable[T]<%String
可以多个上下文界定
T :Ordering:Manifest
类型约束
类型约束提供给你的是另一种限定类型的方式，总共有三种方式可供使用：
T=:=U //T是否等于U
T<:<U //T是否为U的子类型
T<%<U //T是否被视图(隐式)转换为U
这些约束并非内建在语言当中，他们是scala类库提供的特性。
scala> class pair[AA](val f:AA,val s:AA){ def smaller(implicit ord: AA<:<Ordered[AA])={ if (f.compareTo(s)<0) f else s;}}
defined class pair
scala> val p2=new pair("af","dd")
p2: pair[String] = pair@2b149f0a
scala> val p2=new pair[String]("af","dd")
p2: pair[String] = pair@4fc7a2d2
你可以构造出pair[File]对象，尽管File不是带先后次序的，只有调用smaller的时候才会报错
scala> p2.smaller
<console>:19: error: Cannot prove that String <:< Ordered[String].
p2.smaller
^
Option类的orNull方法，orNull的实现带有约束Null<:<A
scala> val fruits=Map((1,"apple"),(2,"orange"),(3,"banana"))
fruits: scala.collection.immutable.Map[Int,String] = Map(1 -> apple, 2 -> orange, 3 -> banana)
scala> fruits.get(2)
res219: Option[String] = Some(orange)
scala> fruits.getOrElse(2,0)
res220: Any = orange
scala> fruits.getOrElse(100,0)
res221: Any = 0
scala> fruits.get(50)
res222: Option[String] = None
scala> val f1=fruits.get(2)
f1: Option[String] = Some(orange)
//final def orNull[A1 >: String](implicit ev: Null <:< A1): A1
scala> f1.orNull
res225: String = orange
scala> val f1=fruits.get(5)
f1: Option[String] = None
scala> f1.orNull
res236: String = null
型变
函数如下
def makfrends(p:Pair[Person])
Student是Person的子类，但我们不能用Pair[Student]作为参数调用makfrends,因为Pair[Student] 和Pair[Person] 没有任何关系
如果想要有关系，Pair类的声明应该如下：
class Pair[+T](val f:T;val s:T)
+T 意味着该类型是T类型协变的，也就是说，它与T按同样的方向形变
Student是Person的子类型,Pair[Student] 也就是Pair[Person]的子类型了
另一个方向的型变 就是[-T],就是逆变了
swap [swɑp] 交换
定义一个不可变类Pair[T,S], 带一个swap方法，返回组件交换过位置的新对偶。
scala> class pair[T,S](first:T,second:S){def swap()={new pair[S,T](second,first)}}
defined class pair
scala> val p1=new pair("100",5)
p1: pair[String,Int] = pair@15fe6b60
scala> val p2=p1.swap()
p2: pair[Int,String] = pair@3a32539
scala> val p1=new pair(100,"dage")
p1: pair[Int,String] = pair@314ba847
scala> val p2=p1.swap()
p2: pair[String,Int] = pair@46007b16
定义一个可变类Pair[T]，带一个swap方法，交换对偶中组件的位置。
scala> class pair[T](var f:T,var s:T){def swap(){ val tmp=f;f=s;s=tmp;println("f:"+f+";s:"+s)};}
defined class pair
scala> val p1=new pair(100,50)
p1: pair[Int] = pair@5120a555
scala> p1.swap
f:50;s:100
给定类Pair[T, S] ，编写一个泛型方法swap，接受对偶作为参数并返回组件交换过位置的新对偶。
scala> class pair[T,S](val first:T,val second:S){ def tostring{ println("f:"+first+";s:"+second)}}
defined class pair
scala> def swap[T,S](p:pair[T,S])={new pair(p.second,p.first)}
swap: [T, S](p: pair[T,S])pair[S,T]
scala> val mm=new pair("dd",84)
mm: pair[String,Int] = pair@785311b4
scala> swap(mm)
res58: pair[Int,String] = pair@7e282649
scala> swap(mm).first
res59: Int = 84
快学scala 17章例四
scala> class Pair[T](val first: T, val second: T) { def replaceFirst(newFirst: T) = new Pair[T](newFirst, second);override def toString = "(" + first + ", " + second + ")";
def replaceFirst2[R >: T](newFirst: R) = new Pair[R](newFirst, second);}
defined class Pair
scala> class Person(val name: String, val age: Int){override def toString = name + " " + age}
defined class Person
scala> class Student(val school: String, name: String, age: Int) extends Person(name, age){override def toString = super.toString + " " + school}
defined class Student
scala> val p1 = new Pair(new Person("tianyongtao", 98), new Person("xiaoma", 56))
p1: Pair[Person] = (tianyongtao 98, xiaoma 56)
scala> val p2 = p1.replaceFirst(new Student("beida", "liu", 101)) //newfirst：Student可以转化成Person（子->父）
p2: Pair[Person] = (liu 101 beida, xiaoma 56)
scala> val p3 = new Pair(new Student("skd", "gang", 81), new Student("shenda", "gggg", 25))
p3: Pair[Student] = (gang 81 skd, gggg 25 shenda)
scala> val p4 = p1.replaceFirst2(new Person("li", 77)) //replaceFirst2函数预定义了新的类型变量下界，second：student转化为Person（子->父）
p4: Pair[Person] = (li 77, xiaoma 56)
scala> val p4 = p3.replaceFirst2(new Person("li", 77))//replaceFirst2函数预定义了新的类型变量下界，second：student转化为Person（子->父）
p4: Pair[Person] = (li 77, gggg 25 shenda)
scala> val p4 = p3.replaceFirst(new Person("li", 77)) //newFirst：Person无法转化为Student（父->子）
<console>:13: error: type mismatch;
found : Person
required: Student
val p4 = p3.replaceFirst(new Person("li", 77))
^
经验证为发现RichInt，应该是BigInt,BigInt的存在丰富了Int，Int可以自动转换为BigInt
使用视图定界可以将Comparable[Int]转化为Comparable[BigInt]
scala> def middle[T](iter:Iterable[T]):T={ val ls=iter.toList;ls(ls.size/2) }
middle: [T](iter: Iterable[T])T
scala> middle("world")
res12: Char = r
