簡單回顧泛型
java中可使用泛型進行編程，一個簡單的泛型例子如下：
List<String> strList = new ArrayList<String>();
strList.add("one");
strList.add("two");
strList.add("three");
String one = strList.get(0); // 泛型拿數據不必進行類型轉換，不使用泛型的話需要對類型進行轉換scala的泛型
scala中的泛型稱爲類型參數化(type parameterlization)。語法跟java不一樣，使用”[]”表示類型。
一個使用類型參數化的函數：
def position[A](xs: List[A], value: A): Int = {
xs.indexOf(value)
}
position(List(1,2,3), 1) // 0
position(List("one", "two", "three"), "two") // 1稍微複雜點的類型參數化，實現一個map函數，需要一個List和一個函數作爲參數：
普通的map方法：
List(1,2,3) map { _ * 2 } // List[Int] = List(2,4,6)
List(1,2,3) map { _ + "2" } // List[String] = List(12, 22, 32)使用泛型實現的map方法：
def map[A,B](list:List[A], func: A => B) = list.map(func)
map(List(1,2,3), { num: Int => num + "2" }) // List[String] = List(12, 22, 32)
map(List(1,2,3), { num: Int => num * 2 }) // List[Int] = List(2, 4, 6)上限和下限
scala跟java一樣，也提供了上限(upper bounds)和下限(lower bounds)功能。
上限(upper bounds)
java中上限的使用如下：
<T extends Object> 通配符形式 <? extends Object>
scala寫法：
[T <: AnyRef] 通配符形式 [_ <: AnyRef]
上限的一些例子：
public void upperBound(List<? extends Number> list) {
Object obj = list.get(0); // Number是Object的子類，使用Object可以代替Number。
Number num = list.get(0);
Integet i = list.get(0); // compile error
list.add(new Integer(1)); // compile error
}上限做參數，set的話不能確定具體的類型，所以會報編譯錯誤。get的話得到的結果的類型的下限爲參數的上限。相當於使用了上限參數的話，該參數就變成了只讀參數，類似生產者，只提供數據。
scala版本：
def upperBound[A <: Animal](list: ListBuffer[A]): Unit = {
list += new Animal("123") // compile error
val obj: AnyRef = list(0) // ok
val a: Animal = list(0) // ok
val a: Cat = list(0) // compile error
}這裏使用ListBuffer作爲集合，ListBuffer的+=方法會在列表內部添加數據，不會產生一個新的List。如果使用List的話，:+操作符會在新生成的List中自動得到符合所有元素的類型。
List[Animal](new Cat()) :+ 1 // List[Any] = List(Cat@3f23a076, 1)
生成新的List會自動根據上下文得到新的泛型類型List[AnyRef]。
下限(lower bounds)
<T super MyClass> 通配符形式 <? super MyClass>
scala寫法：
[T >: MyClass] 通配符形式 [_ >: MyClass]
下限的一些例子：
public static void lowerBound(List<? super Number> l) {
l.add(new Integer(1));
l.add(new Float(2));
Object obj = l.get(0);
Number num = l.get(0); // compile error
}下限做參數，get方法只能用最寬泛的類型來獲取數據，相當於get只提供了數據最小級別的訪問權限。類似消費者，主要用來消費數據。
scala版本：
def lowerBound[A >: Animal](list: ListBuffer[A]): Unit = {
list += new Animal() // ok
list += new Cat() // ok
val obj: Any = list(0) // ok
val obj: Animal = list(0) // compile error
}協變和逆變
協變(covariance)：對於一個帶類型參數的類型，比如List[T]，如果對A及其子類型B，滿足List[B]也符合List[A]的子類型，那麼就稱爲協變，用加號表示。比如 MyType[+A]
逆變(contravariance)：如果List[A]是List[B]的子類型，用減號表示。比如MyType[+B]
如果一個類型支持協變或逆變，則稱這個類型爲可變的(variance)。否則稱爲不可變的(invariant)。
在java裏，泛型類型都是不可變的，比如List<String>並不是List<Object>的子類。
trait A[T] class C[T] extends A[T] class Parent; class Child extends Parent val c:C[Parent] = new C[Parent] // ok val c:C[Parent] = new C[Child]; // Child <: Parent, but class C is invariant in type T.
協變
上面的例子提示已經很明確了。類C是不可變的，改成協變即可。
trait A[+T] class C[+T] extends A[T] class Parent; class Child extends Parent val c: C[Parent] = new C[Parent] // ok val c: C[Parent] = new C[Child] // ok
scala中List就是一個協變類。
val list:List[Parent] = List[Child](new Child())
逆變
逆變概念與協變相反。
trait A[-T] class C[-T] extends A[T] class Parent; class Child extends Parent val c: C[Parent] = new C[Parent] // ok val c: C[Child] = new C[Parent] // ok
協變逆變注意點
逆變協變並不會被繼承，父類聲明爲逆變或協變，子類如果想要保持，任需要聲明：
trait A[+T] class C[T] extends A[T] // C是不可變的，因爲它不是逆變或協變。 class D[+T] extends A[T] // D是可變的，是協變 class E[-T] extends A[T] // E是可變的，是逆變