泛型類

泛型類：在Scala的類中定義引數型別
泛型類的應用場景：對類中的某些成員(field和method中的引數或變數)進行統一的型別限制，從而確保程式的健壯性和穩定性

class MyCollection[T]{
  private val list =new  ListBuffer[T]()
  //增加一個元素
  def add(el:T): Unit ={
    list.append(el)
  }
  //刪除
  def remove(el:T): Unit ={
    list.-=(el)
  }

  override def toString = s"MyCollection($list)"
}
object MyCollection{
  def main(args: Array[String]): Unit = {
  //定義前宣告泛型型別
    val c = new MyCollection[Int]()
    c.add(2:Int)
    println(c)
    c.remove(2:Int)
    println(c)

  }
}
 

泛型函式

泛型函式：類似於泛型類，在宣告函式時指定泛型型別，然後在函式體中，就可以使用這種泛型型別來宣告變數或作為函式的返回值型別，從而強制性對變數或返回值進行型別限制。

class School{}
class Student(name:String) extends School{}
class Teacher(name:String) extends School{}
class Whh(name:String){}
object FunDemo  {
   def main(args: Array[String]): Unit = {
     val student = new Student("小李")
     val teacher = new Teacher("jack")
     val w = new Whh(" www")
     door[School](student)
     door[School](teacher)
     //door[School](w)
   }
  def door[T](per:T): Unit ={
    if(per.getClass == classOf[Student]){
      println("student 允許進入")
    }else if(per.getClass == classOf[Teacher]){
      println("teacher 允許進入")
    }else{
      println("不允許進入。。。")
    }
  }
}
 

上邊界

Scala中的上邊界定義語法：T <: 父類

package cn.alibaba.scala.genericity
class Shool{
  var name:String = _
  def chat(s:Shool): Unit ={
    println(this.name+"和"+s.name+"一起聊天")
  }
}
class Student(stuName:String) extends Shool{
   this.name = stuName
}
class Teacher(teaName:String) extends Shool{
  this.name = teaName
}
class Stranger(name: String){}
//定義泛型邊界 最大 為Shool
class Party[T <: Shool](p1:T,p2:T){
  def eat = p1.chat(p2)
}
object Party {
  def main(args: Array[String]): Unit = {
    val stu = new Student("魯魯")
    val tea = new Teacher("卡卡")
    val str = new Stranger("路人")

    val par = new Party(stu,tea)
    par.eat
  }
}

 

下邊界

Scala中的上邊界定義語法：T >: 子類

class GranderFather
class Father extends GranderFather
class Son extends Father
class Tongxue
object Card{
//最小邊界為father類
  def getIDCard[T >: Father](person:T): Unit ={
    println("OK,交給你了")
  }
  def main(args: Array[String]): Unit = {
    getIDCard[GranderFather](new Father)
    getIDCard[GranderFather](new GranderFather)
    /**
    * 下面程式碼回報錯 邊界Father
    */
    getIDCard[Son](new Son)
    //getIDCard[GranderFather](new Tongxue)//報錯，所以註釋

  }
}

認真看下邊界這段程式碼就會體會到泛型邊界的含義以及控制範圍！