类型参数类似于Java中的泛型。注意了，是类型参数，不是参数类型， 顾名思义，就是把类型作为参数。跟Java泛型一样，在集合，类，函数中定义参数类型，然后保证 使用到该类型参数的地方，只能用这种类型，否则编译器报错。在编译期就能发现错误可以大大降低开发成本。
这里说的成本我是很想讨论下，开发成本，不仅仅指的是钱。如你在编写代码时，IDE就提示你错误了。这时候你就不用浪费时间去点击运行才发现错误，从而节省了你的时间，你可能会说时间就是钱啊，实际不那么是，因为得看角度，你的时间或许是你的金钱，但对于老板来说不是，因为你一天无论干什么，发呆、百度资料或做了个功能，老板都是给一样的钱。但开发成本，我觉得能够全面客观的描述这个项目花的劳动时间及资源。
泛型类
泛型类，顾名思义，其实就是在类的声明中，定义一些泛型类型，然后在类的内部，比如field或者method中使用。
使用泛型类，同城需要对类中的某些成员， 比如某些field或method中的参数或变量，进行统一的类型限制，这样可以保证程序更好的健壮性和稳定性。在编译期就能发现错误。
如果不是使用泛型进行统一的类型限制，那么在运行时发现错误，则处理错误的成本就要高很多了。
在使用类的时候，比如创建对象，将类型参数替换为实际的类型即可。或者直接给使用了泛型类的field赋值是，scala会自动进行类型推断。
例子：新生报到，每个学生来自不同的地方，id可能是Int，也可能是String
clas Student[T](val localId:T){
def getSchoolId(id:T) = "S-"+id+"-"+localId
}
val jc = new Student[Int](700)
jc.getSchoolId("jc");
jc.getSchoolId(10);
泛型函数
泛型函数，与泛型类类似，可以给某个函数在声明时指定泛型类型，然后在函数体内，多个变量或返回值之间，就可以使用泛型类型进行声明，从而对某个特殊的变量，或者多个变量，进行强制性的类型限制。
与泛型类一样，你可以通过使用了泛型类型的变量传递值来让scala自动推断泛型的是积累下，也可以在调用函数时，手动指定函数类型。
例子：卡片售卖机，可以指定卡片的内容，内容可以是String类型或者Int类型
def getCard[T](content:T)={
if(content.isInstanceOf[Int]) "card:001,"+content
else if(content.isInstanceOf[String]) "card: this your card, "+content
else "card: "+content
}上边界Bounds
在指定泛型类型的是偶，有时我们需要对泛型类型的范围进行界定，而不是可以是任意的类型。比如，我们可能要求某个泛型类型，它就必须是某个类的子类，这样在程序中就可以放心地调用泛型类型继承弗雷的方法，程序才能正常的使用和运行。此时就可以使用上下边界Bounds的特性。
scala的上下边界特性允许泛型类型必须是某个类的子类，或者必须是某个类的弗雷。
上边界Bounds语法： T<:Person
例子：在派对上交朋友
class Person(val name:String){
def sayHello = println("Hello, I'm "+ name)
def makeFriends(p:Person){
sayHello
p.sayHello
}
}
class Student(name:String) extends Person(name)
class Other(name:String)
class Party[T<:Person](p1:T,p2:T){
def play = p1.makeFriends(p2);
}
scala> val s = new Student("jc")
s: Student = Student@718632e9
scala> val s2 = new Student("jc2")
s2: Student = Student@3540ee91
scala> val p = new Party(s,s2)
p: Party[Student] = Party@77240ed1
scala> p.play
Hello, I'm jc
Hello, I'm jc2
scala> val s3 = new Person("jc2")
s3: Person = Person@38c9c7a0
scala> val p = new Party(s,s3)
p: Party[Person] = Party@fa7e87b
scala> val o = new Other("o")
o: Other = Other@40cecfc0
scala> val p = new Party(s,o)
<console>:14: error: inferred type arguments [Object] do not conform to class Party's type parameter bounds [T <: Person]
val p = new Party(s,o)
^
<console>:14: error: type mismatch;
found : Student
required: T
val p = new Party(s,o)
^
<console>:14: error: type mismatch;
found : Other
required: T
val p = new Party(s,o)
^语法[T<:Person]，只要是Person类或及其子类即可。
下边界Bounds
下边界，指定类型必须是某个类的父类
下边界Bounds语法： T>:Child
例子：领身份证
class Father(val name:String)
class Child(name:String) extends Father(name)
class GrandChild(name:String) extends Child(name)
def getIdCard[R>:Child](p:R){
if(p.getClass == classOf[Child]) println("please tell us your parents' names.")
else if(p.getClass == classOf[Father]) println("sign your name to get your child's id card.")
else println("sorry, you are not allowed to get id card.")
}
val c = new Child("jc child")
val p = new Father("jc father")
getIdCard(c)
getIdCard(p)
val g = new GrandChild("jc grandechild")
getIdCard(g) //可执行成功
// 想要编译器能发现错误，就只能在调用函数式，指定类型参数
scala> getIdCard[GrandChild](g)
<console>:16: error: type arguments [GrandChild] do not conform to method getIdCard's type parameter bounds [R >: Child]
getIdCard[GrandChild](g)
View Bounds
上下边界Bounds，虽然可以让一种泛型类型，支持父子关系的多种类型。但是，在某个类与上下边界Bounds指定的父子类型范围内的类都没有任何关系，则默认是肯定不能接受的。
然而，View Bounds作为一种上下边界Bounds的加强版，支持对类型进行隐时转换，将指定的类型进行隐式转换后，再判断是否在边界指定得了类型范围内。
上边界Bounds语法： T>:Person
例子：跟小狗交朋友
class Person(val name:String){
def sayHello = println("Hello, I'm " + name)
def makeFriends(p:Person){
sayHello
p.sayHello
}
}
class Student(name:String) extends Person(name)
//特定于法，<% 代表Person及Person以下的类，可以包括隐式转换的
class Party[T<%Person](p1:T,p2:T){
def play = p1.makeFriends(p2);
}
scala> val s = new Student("jc")
s: Student = Student@3e1e52b8
scala> val p = new Person("jcp")
p: Person = Person@44f8d156
scala> val party = new Party(s,p)
party: Party[Person] = Party@587f3671
scala> party.play
Hello, I'm jc
Hello, I'm jcp
class Dog(val name:String){def sayHello = println("Wang, Wang, I'm "+ name)}
scala> val d = new Dog("jdog")
d: Dog = Dog@729dc481
//报错，因为没有指定隐式转换
scala> val party = new Party(s,d)
<console>:14: error: No implicit view available from Object => Person.
val party = new Party(s,d)
^
implicit def dog2person(dog: Object): Person= if(dog.isInstanceOf[Dog]){val _dog = dog.asInstanceOf[Dog]; new Person(_dog.name)} else Nil
//需指定泛型类型，不然party.play就一直卡住
scala> val party = new Party[Person](s,d)
party: Party[Person] = Party@702a694f
scala> party.play
Hello, I'm jc
Hello, I'm jdog
Context Bounds
Context Bounds是一种特殊的Bounds，它会根据泛型类型的声明，比如“T:类型”要求必须存在一个类型为“类型[T]”的隐式值。
就是可以使用scala的隐式类，并且可以控制参数类型的一致性
例子： 使用scala内置的比较器比较大小
class Calculator[T: Ordering](val number1:T, val number2:T){
def max(implicit order: Ordering[T]) = if(order.compare(number1,number2)>0) number1 else number2
}
scala> val c = new Calculator(1,2)
c: Calculator[Int] = Calculator@c62b064
scala> c.max
res6: Int = 2
scala> val c = new Calculator(1,"2")
<console>:13: error: No implicit Ordering defined for Any.
val c = new Calculator(1,"2")
^
scala> val c = new Calculator("3","2")
c: Calculator[String] = Calculator@409c4578
scala> c.max
res7: String = 3
泛型数组
如果想实例化一个泛型数组，需运用到Manifest Context Bounds。也就是说，如果数组元素类型为T的话，需要为类或函数定义[T:Manifest]类型参数。
简单直白地说就是 固定语法，类和函数必须定义[T:Manifest]，其里面才能使用泛型数组。
例子： 打包饭菜（不同食物类型分开打包）
class Meat(val name:String)
class Vegetable(val name:String)
def packageFood[T:Manifest](food: T*) = {
val foodPackage = new Array[T](food.length)
for(i <-0 until food.length) foodPackage(i) = food(i)
foodPackage
}
scala> packageFood(new Meat("m1"),new Meat("m2"))
res8: Array[Meat] = Array(Meat@18f4a2ae, Meat@7e319726)
//由于scala有自动推断功能，所以想要编译期发现错误，需指定类型参数
scala> packageFood(new Meat("m1"),new Vegetable("v2"))
res9: Array[Object] = Array(Meat@4c1bd6ce, Vegetable@16a7770b)
//由于scala有自动推断功能，所以想要编译期发现错误，需指定类型参数
scala> packageFood[Meat](new Meat("m1"),new Vegetable("v2"))
<console>:16: error: type mismatch;
found : Vegetable
required: Meat
packageFood[Meat](new Meat("m1"),new Vegetable("v2"))
协变和逆变
scala的协变和逆变是非常有特色的，完全解决了java中的泛型的一大遗憾。
举例子说，java中，如果有Professional是Master的子类，那么Card[Professional]是不是Card[Master]的子类？答案是：不是的。
例子：进入会场
class Master
class Professional extends Master
//大师以及大师级别以下的名片都可以进入会场
//
class Card[+T] (val name:String)
def enterMeet(card:Card[Master]){
println("welcome to have this meeting")
}
scala> val p = new Card[Professional]("p")
p: Card[Professional] = Card@49f8e77c
scala> enterMeet(p)
welcome to have this meeting
scala> val m = new Card[Master]("m")
m: Card[Master] = Card@125d05e2
scala> enterMeet(m)
welcome to have this meeting
协变，在上述例子也就是Card[Profession]是Card[Master]的子类，协变的语法是[+T]，对比[T]:
scala> class Card[T] (val name:String)
defined class Card
scala> val p = new Card[Professional]("p")
p: Card[Professional] = Card@6732963b
def enterMeet(card:Card[Master]){
println("welcome to have this meeting")
}
scala> enterMeet(p)
<console>:15: error: type mismatch;
found : Card[Professional]
required: Card[Master]
enterMeet(p)
逆变，也就是上述例子Card[Master]是Card[Profession]的父类，逆变的语法是[-T]，对比[+T]:
scala> class Card[-T](val name:String)
defined class Card
def enterMeet(card:Card[Master]){
println("welcome to have this meeting")
}
scala> val p = new Card[Professional]("p")
p: Card[Professional] = Card@584ff37c
scala> enterMeet(p)
<console>:15: error: type mismatch;
found : Card[Professional]
required: Card[Master]
enterMeet(p)
^
//只要专家级别的名片就可以进入会场，如果大师级别的过来了，当然可以了！
def enterMeet(card:Card[Professional]){
println("welcome to have this meeting")
}
scala> enterMeet(p)
welcome to have this meeting
scala> val m = new Card[Master]("m")
m: Card[Master] = Card@7ef67f5d
scala> enterMeet(p)
welcome to have this meeting
要点，协变和逆变的语法，可以让原本控制泛型很死的类或函数，扩展到其泛型的父类或子类：
协变，可以让函数enterMeet(card:Card[Master])，原本是只能Master的Card参数，现在只需要Card[+T]，即可传入Card[Master]和Card[Professional]参数。也就是可以传入某类及其子类的参数。
协变跟上边界[T<:]不一样，协变讨论的是Card[Professional]是不是Card[Master]的子类。而上边界[T<:]讨论的是Professional是不是Master的子类。从数学上来比喻它们不一样就是，定义域不一样，所以协变跟上边界[T<:Card]不是同个东西，更加没有好对比。
逆变，理解了协变，那逆变就更好理解了，可以让函数enterMeet(card:Card[Professional])，原本是只能Professional的Card参数，现在只需要Card[-T]，即可传入Card[Master]和Card[Professional]参数。也就是可以传入某类及其父类的参数。
