Scala泛型

<p>       泛型的意思是<strong>泛指某种具体的数据类型</strong>, 在Scala中, 泛型用<strong>[数据类型]</strong>表示. 在实际开发中, 泛型一般是结合数组或者集合来使用的, 除此之外, 泛型的常见用法还有以下三种:</p><ul><li><p>泛型方法</p></li><li><p>泛型类</p></li><li><p>泛型特质</p></li></ul><p><strong>1.1 泛型方法</strong></p><p>泛型方法指的是<strong>把泛型定义到方法声明上, 即:该方法的参数类型是由泛型来决定的</strong>. 在调用方法时, 明确具体的数据类型.</p><p><strong>格式</strong></p><pre>def 方法名泛型名称 = {    //...}</pre><p><strong>需求</strong></p><p>定义方法getMiddleElement(), 用来获取任意类型数组的中间元素.</p><ul><li><p>思路一: 不考虑泛型直接实现（基于Array[Int]实现）</p></li><li><p>思路二: 加入泛型支持.</p></li></ul><p><strong>参考代码</strong></p><pre>//案例: 泛型方法演示.//细节: 泛型方法在调用方法的时候 明确具体的数据类型.object ClassDemo01 {  //需求: 用一个方法来获取任意类型数组的中间的元素  //思路一:不考虑泛型直接实现（基于Array[Int]实现）  //def getMiddleElement(arr: Array[Int]) = arr(arr.length / 2)  //思路二: 加入泛型支持  def getMiddleElementT = arr(arr.length / 2)  def main(args: Array[String]): Unit = {      //调用方法      println(getMiddleElement(Array(1, 2, 3, 4, 5)))      println(getMiddleElement(Array("a", "b", "c")))  }}</pre><p><strong>1.2 泛型类</strong></p><p>泛型类指的是<strong>把泛型定义到类的声明上, 即:该类中的成员的参数类型是由泛型来决定的</strong>. 在创建对象时, 明确具体的数据类型.</p><p><strong>格式</strong></p><pre>class 类T</pre><p><strong>需求</strong></p><ol><li><p>定义一个Pair泛型类, 该类包含两个字段，且两个字段的类型不固定.</p></li><li><p>创建不同类型的Pair泛型类对象，并打印.</p></li></ol><p><strong>参考代码</strong></p><pre>//案例: 泛型-演示泛型类的使用.//泛型类: 在创建对象的时候, 明确具体的数据类型.object ClassDemo02 {  //1. 实现一个Pair泛型类  //2. Pair类包含两个字段，而且两个字段的类型不固定  class PairT  def main(args: Array[String]): Unit = {    //3. 创建不同类型泛型类对象，并打印    var p1 = new PairInt    println(p1.a, p1.b)    var p2 = new PairString    println(p2.a, p2.b)  }}</pre><p><strong>1.3 泛型特质</strong></p><p>泛型特质指的是<strong>把泛型定义到特质的声明上, 即:该特质中的成员的参数类型是由泛型来决定的</strong>. 在定义泛型特质的子类或者子单例对象时, 明确具体的数据类型.</p><p><strong>格式</strong></p><pre>trait 特质A[T] {  //特质中的成员}class 类B extends 特质A[指定具体的数据类型] {  //类中的成员}</pre><p><strong>需求</strong></p><ol><li><p>定义泛型特质Logger, 该类有一个变量a和show()方法, 它们都是用Logger特质的泛型.</p></li><li><p>定义单例对象ConsoleLogger, 继承Logger特质.</p></li><li><p>打印单例对象ConsoleLogger中的成员.</p></li></ol><p><strong>参考代码</strong></p><pre>//案例: 演示泛型特质.object ClassDemo03 {  //1. 定义泛型特质Logger, 该类有一个a变量和show()方法, 都是用Logger特质的泛型.  trait Logger[T] {    //定义变量    val a:T    //定义方法.    def show(b:T) = println(b)  }  //2. 定义单例对象ConsoleLogger, 继承Logger特质.  object ConsoleLogger extends Logger[String]{    override val a: String = "张三"  }  //main方法, 作为程序的主入口.  def main(args: Array[String]): Unit = {    //3. 打印单例对象ConsoleLogger中的成员.    println(ConsoleLogger.a)    ConsoleLogger.show("10")  }}</pre><p><strong>2. 上下界</strong></p><p>我们在使用泛型(方法, 类, 特质)时，如果要限定该泛型必须从哪个类继承、或者必须是哪个类的父类。此时，就需要使用到<strong>泛型的上下界</strong>。</p><p><strong>2.1 上界</strong></p><p>使用<strong>T <: 类型名</strong>表示给类型添加一个<strong>上界</strong>，表示泛型参数必须要从该类（或本身）继承.</p><p><strong>格式</strong></p><pre>[T <: 类型]</pre><blockquote><p>例如: [T <: Person]的意思是, 泛型T的数据类型<strong>必须是Person类型或者Person的子类型</strong></p></blockquote><p><strong>需求</strong></p><ol><li><p>定义一个Person类</p></li><li><p>定义一个Student类，继承Person类</p></li><li><p>定义一个泛型方法demo()，该方法接收一个Array参数.</p></li><li><p>限定demo方法的Array元素类型只能是Person或者Person的子类</p></li><li><p>测试调用demo()方法，传入不同元素类型的Array</p></li></ol><p><strong>参考代码</strong></p><pre>//案例: 演示泛型的上下界之  上界.object ClassDemo04 {  //1. 定义一个Person类  class Person  //2. 定义一个Student类，继承Person类  class Student extends Person  //3. 定义一个demo泛型方法，该方法接收一个Array参数，  //限定demo方法的Array元素类型只能是Person或者Person的子类  def demoT <: Person = println(arr)  def main(args: Array[String]): Unit = {    //4. 测试调用demo，传入不同元素类型的Array    //demo(Array(1, 2, 3))          //这个会报错, 因为只能传入Person或者它的子类型.    demo(Array(new Person()))    demo(Array(new Student()))  }}</pre><p><strong>2.2 下界</strong></p><p>使用<strong>T >: 数据类型</strong>表示给类型添加一个<strong>下界</strong>，表示泛型参数必须是从该类型本身或该类型的父类型.</p><p><strong>格式</strong></p><pre>[T >: 类型]</pre><blockquote><p>注意:</p><ol><li><p>例如: [T >: Person]的意思是, 泛型T的数据类型<strong>必须是Person类型或者Person的父类型</strong></p></li><li><p>如果泛型既有上界、又有下界。下界写在前面，上界写在后面. 即: <strong>[T >: 类型1 <: 类型2]</strong></p></li></ol></blockquote><p><strong>需求</strong></p><ol><li><p>定义一个Person类</p></li><li><p>定义一个Policeman类，继承Person类</p></li><li><p>定义一个Superman类，继承Policeman类</p></li><li><p>定义一个demo泛型方法，该方法接收一个Array参数，</p></li><li><p>限定demo方法的Array元素类型只能是Person、Policeman</p></li><li><p>测试调用demo，传入不同元素类型的Array</p></li></ol><p><strong>参考代码</strong></p><pre>//案例: 演示泛型的上下界之 下界.//如果你在设定泛型的时候, 涉及到既有上界, 又有下界, 一定是: 下界在前, 上界在后.object ClassDemo05 {  //1. 定义一个Person类  class Person  //2. 定义一个Policeman类，继承Person类  class Policeman extends Person  //3. 定义一个Superman类，继承Policeman类  class Superman extends Policeman  //4. 定义一个demo泛型方法，该方法接收一个Array参数，  //限定demo方法的Array元素类型只能是Person、Policeman  //          下界          上界  def demoT >: Policeman <: Policeman = println(arr)  def main(args: Array[String]): Unit = {    //5. 测试调用demo，传入不同元素类型的Array    //demo(Array(new Person))    demo(Array(new Policeman))    //demo(Array(new Superman))     //会报错, 因为只能传入: Policeman类获取它的父类型, 而Superman是Policeman的子类型, 所以不行.  }}</pre><p><strong>2.3 上下文限定</strong></p><p><strong>语法</strong></p><pre>def fA : B = println(a) //等同于 def fA(implicit arg:B[A])=println(a) 2）</pre><p><strong>说明</strong>
上下文限定是将泛型和隐式转换的结合产物，以下两者功能相同，使用上下文限定[A : Ordering]之后，方法内无法使用隐式参数名调用隐式参数，需要通过 implicitly[Ordering[A]] 获取隐式变量，如果此时无法查找到对应类型的隐式变量，会发生出错误。</p><pre>implicit val x = 1val y = implicitly[Int] val z = implicitly[Double]</pre><p><strong>案例</strong></p><pre>def fA:Ordering =implicitly[Ordering[A]].compare(a,b) def fA(implicit ord: Ordering[A]) = ord.compare(a, b)</pre><p><strong>3. 协变、逆变、非变</strong></p><p>非变: 类A和类B之间是父子类关系, 但是Pair[A]和Pair[B]之间没有<strong>任何关系</strong>.</p><p>协变: 类A和类B之间是父子类关系, Pair[A]和Pair[B]之间也有<strong>父子类</strong>关系.</p><p>逆变: 类A和类B之间是父子类关系, 但是Pair[A]和Pair[B]之间是<strong>子父类</strong>关系.</p><pre>class MyList[+T]{ //协变}class MyList[-T]{ //逆变}class MyList[T] //非变</pre><p>默认是非变</p><p><strong>案例</strong></p><pre>//非变//class MyList[T]{}//协变//class MyList[+T]{}//逆变//class MyList[-T]{}class Parent{}class Child extends Parent{} class SubChild extends Child{}object Scala_TestGeneric {def main(args: Array[String]): Unit = {//var s:MyList[Child] = new MyList[SubChild]}}</pre><p>
</p>