package com.ming.test

/**

 * scala泛型

 * 类型参数测试

 */

object TypeParamsTest {

  //泛型函数

  def getMiddle[T](a:Array[T])=a(a.length/2)

   //类型通配符

  def process1(people:java.util.List[_<:Student])={}

  def main(args: Array[String]): Unit = {

    val p=new Pair(42,"String")

    val p2=new Pair[Any,Any](42,"ddd")

    val c=new Compare("A","B");

    println(c.smaller)

  }

}

//定义一个类型参数的类

class Pair[T,M](var one:T,var two :M)

//T必须是Comparable[T]的子类型.

class Compare[T<:Comparable[T]](val one:T,val two : T){

  def smaller=if(one.compareTo(two)<0) one else two

}

//视图界定

/**

 * <%关系意味这T可以被隐式转换成Comparable[T],还可以用Ordered特质

 */

class PairT[T <% Comparable[T]]

class PairTT[T <% Ordered[T]](val one:T,val two:T){

  def smaller=if(one<two) one else two

}

//上下文界定

class P[T : Ordering](val one:T,val two:T){

  def smaller(implicit ord: Ordering[T])=

    if(ord.compare(one, two)<0) one else two

}

//Manifest上下文界定

class ManfiestTest{

  def makePair[T : Manifest](one:T,two :T){

    val r=new Array[T](2)

    r(0)=one

    r(1)=two

  }

}

//多重界定，其实就是限定类型范围

class A[T <:Comparable[T] with Serializable with Cloneable]

class B[T <% Comparable[T] <% String]

class C[T : Ordering : Manifest]

class D[T >: String <:String]

abstract class List[+T]{

  def isEmpty :Boolean

  def head :T

  def tail: List[T]

}

object Empty extends List[Nothing]{

  def isEmpty=true

  def head=throw new UnsupportedOperationException

  def tail=throw new UnsupportedOperationException

}

class Student{}