从零学scala（九）类型参数、高级类型

泛型类

         //泛型类，基本和java是一致的
         class Pair[T,S](val first:T,val second:S)

         val pair1 = new Pair("42",42)
         val pair2 = new Pair[Any,Any](42,"42")

泛型函数

         //返回数组中间的值
         def getMiddle[T](a:Array[T]) = a(a.length/2)

         def main(args: Array[String]): Unit = {
                  val f = getMiddle(Array("a","b","c","d","e"))
                  println(f.mkString("|"))
         }

类型变量界定

         //定义一个参数类，它必须是Comparable的子类
         class Middle[T <: Comparable[T]](val first:T ,val second:T) {
                  val smaller = if(first.compareTo(second) < 0) first else second
         }

视图界定

          //使用<%的含义是可以将变量隐式转换为Comparable的子类。前提是必须存在这种隐式转换！！！
          class Middle[T <% Comparable[T]](val first:T ,val second:T) {
                    val smaller = if(first.compareTo(second) < 0) first else second
          }

上下文界定

          //必须存在一个一个类型为Ordering的值
          class Middle[T : Ordering](val first:T ,val second:T) {
                    def smaller(implicit ord:Ordering[T])
                              = if(ord.compare(first,second) < 0) first else second
          }

Manifest上下文界定

          //在虚拟机中，泛型相关的类型信息是被抹除的，所有Array方法只有一个
          //方法。例如你调用int类型的，只是产生了一个intManifest方法

          def makePair[T:Manifest](first:T,second:T){
                    val r = new Array[T](2)
                    r(0) = first
                    r(1) = second
                    r
          }

多重界定

          //上界和下界
          Lower >:makePair <: Upper
          //类型实现多个特质
          makePair <: Compareable[makePair] with Serializable with Cloneable
          //多个试图界定
          makePair <% Compareable[makePair] <% String
          //多个上下文界定
          makePair : Ordering : Maifest

类型约束

          // T =:= U T是否等于U
          // T <:< U T是否U的子类型
          // T =%= U T能否被隐式转换为U类型
          class Pair[T](first:T,second:T){
                    implicit ev:T =:=Compareable[T]
          }

型变

          //T类型及子类型可以访问：协变
          class Pair[+T](first:T,second:T){}
          //逆变：父类传递参数到子类
          class Pair1[-T](first:T,second:T){}

协变和逆变点

对象不能泛型

类型通配符

单例类型

        这个就不多说了,在java里面经常用.但是有一个特殊的地方,关于返回类型:

        class Document{
                def setTitle(title:String) ={
                        println("title:"+title)
                        this
                }
        }
        class Book extends Document{
                def setPrice(price:String) ={
                        println("price:"+price)
                        this
                }
        }

        val book = new Book
        book.setPrice("bb").setTitle("aa")    //这时候代码会报错,因为book没有setTitle方法

        class Document{
                def setTitle(title:String):this.type ={//修改返回格式
                        println("title:"+title)
                        this
                }
        }
        class Book extends Document{
                def setPrice(price:String):this.type ={//修改返回格式
                        println("price:"+price)
                        this
                }
        }

类型投影

        class Network {
                class Member(val name: String) {
                        var contacts = new util.ArrayList[Member]()
                }
                private val members = new ArrayBuffer[Member]()

                def join(name: String): Member = {
                        val m = new Member(name)
                        members += m
                        m
                }
        }

        val chatter = new Network
        val myFace = new Network

        val fred = chatter.join("Fred")
        val barney = myFace.join("Barney")
        fred.contacts.add(barney)//这时候chatter和myFace的Member是不同

        var contacts = new util.ArrayList[Network#Member]() //将类型变为只要是Member就行

路径

          val aa = new Network#Member

          println(aa.contacts)//new内部类对象

类型别名

          并没有试验出来书上的效果.尴尬尴尬

          class Book{
                    import scala.collection.mutable._
                    val Index = HashMap[String,String]
          }

          可以直接使用Book.Index来重命名HashMap,但是没有起作用

结构类型

复合类型

中置类型

存在类型

scala类型系统

自身类型

依赖注入

抽象类型

家族多态

高等类型