ToB企服应用市场:ToB评测及商务社交产业平台

标题: Scala泛型 [打印本页]
作者: 美丽的神话    时间: 2023-6-22 04:10
标题: Scala泛型
泛型的定义
  1. object _11_泛型 {
  2.   def main(args: Array[String]): Unit = {
  3.     //[A]  这个代表的就是泛型  ==》 在创建对象的时候，可以指定需要传进去的类型
  4.     //作用就是在创建对象的时候，可以对传进去的参数一个约束，当设置泛型位int之后，那么传进去的值就必须是int
  5.     //apply[A](xs: A*): List[A] = xs.toList
  6.     val ints: List[Int] = List[Int](1, 2, 3, 4)
  8.     //自己写一个？  单纯演示泛型语法的定义，没有什么实际的意义
  9.     /**
  10.      * 将泛型定义在类上，那么在整个类中，都可以使用该泛型，作用域是整个类
  11.      * @tparam T
  12.      */
  13.     class TestFanXin[T](){
  14.       def max(a:T,b:T)= a
  15.     }
  16.     //如果设置泛型位Int类型，那么方法的参数就只能传Int类型
  17.     new TestFanXin[Int]().max(1,2)
  18.     //如果设置泛型位String类型，那么方法的参数就只能传String类型
  19.     new TestFanXin[String]().max("aa","bb")
  21.     /**
  22.      * 泛型也可以定义在方法上，如果定义在方法上，那么该泛型的作用域只能作用在该方法中
  23.      * 出了该方法便不能生效
  24.      */
  25.     class TestFanXin1(){
  26.       def max[T](a:T,b:T)= a
  27.       def min[A](a:A,b:A)= b
  28.     }
  29.   }
  30. }
复制代码
泛型上下限

泛型的上下限的作用是对传入的泛型进行限定。
语法：
  1. //泛型上限  只能够传Person 这个类和他的的子类
  2. Class PersonList[T <: Person]{
  3. }
  4. //泛型下限 只能够传Person 这个类和他的的父类
  5. Class PersonList[T >: Person]{
  6. }
复制代码
代码示例：
  1. package com.doit.day02
  4. object _12_泛型的上下限 {
  5.   def main(args: Array[String]): Unit = {
  7.     def sayHi[A <: Father](a:A): Unit ={
  8.       println("test")
  9.     }
  11.     def sayHello[A >: Father](a:A): Unit ={
  12.       println("test")
  13.     }
  15.     //调用sayHi的时候，传进去的参数因为有泛型的上界约定，所以只能传入Father和Father的子类
  16.     sayHi(new Son())
  17.     sayHi(new Father())
  18.     //这边编译的时候虽然不报错，但是运行的时候会报错
  19. //    sayHi(new GrandFather())
  21.     //如果泛型是定义在方法上的，如果没有加泛型，是限制不住的，但是加了泛型，还是可以限制住的
  22. //    sayHello[ABC](new ABC)
  23. //    sayHello[Son](new Son)
  24.     sayHello(new Father)
  25.     sayHello(new GrandFather)
  28.     class Test[A >:Father]{
  29.       def sayHi(a:A) ={
  30.         println("hello")
  31.       }
  32.     }
  34.     new Test[Father].sayHi(new Father)
  35.     //如果定义在类上的话，就能约束住了
  36. //    new Test[Son].sayHi(new Son)
  37.     new Test[GrandFather].sayHi(new GrandFather)
  42.   }
  43. }
  45. class Son extends Father
  47. class Father extends GrandFather
  49. class GrandFather
  51. class ABC
复制代码
视图限定


约束本质：存在一个隐式转换，能够将T类型转换成B类型
泛型视图限定：T  0) cat else cat1    }    //不过回头想比较狗狗，又要写一个，比较麻烦，不通用    //这时候就可以定义泛型了    def bigger2[T](t: T,t1:T,cmp:Ordering[T]):T={      if (cmp.compare(t,t1)> 0) t else t1    }    //方法的调用  这样是没什么问题的    //但是在马大爷眼里，这么写代码，多low啊，不符合马大爷的气质，他就开始搞事情了    bigger2[Cat](Cat(10,100),Cat(20,80),new Ordering[Cat] {      override def compare(x: Cat, y: Cat) = x.age - y.age    })    //咱们不是有隐式转换嘛，能不能把这个比较器呢？    //我上下文中找找，有没有什么隐式的比较器可以拿过来用，如果有我就直接拿过来，这样就不用传比较器了，去偷一个不香嘛    //bigger3[T :Ordering]  注意：如果想让他自己偷一个，那么需要实现上下文界定，不然是没办法使用的    def bigger3[T :Ordering](t: T,t1:T):T={      if(implicitly[Ordering[T]].compare(t,t1)>0) t else t1    }    /**     * 两种创建隐式比较器对象的写法     */    //    implicit val value: Ordering[Cat] = new Ordering[Cat] {//      override def compare(x: Cat, y: Cat) = x.age - y.age//    }    implicit val value1 = Ordering.by[Cat,Int](cat=>cat.age)    bigger3[Cat](Cat(10,100),Cat(20,80))  }}[/code]逆变，协变，不变

语法：
不变：默认
协变： +T
逆变： -T
  1. package com.doit.day02
  3. object _13_视图限定 {
  4.   def main(args: Array[String]): Unit = {
  6.     class Bird(val name:String){
  7.       def fly()={println(name + "飞走了")}
  8.     }
  10.     class ToyBird
  12.     def bitBird[T <% Bird](b:T)=b.fly()
  14.     bitBird[Bird](new Bird("小鸟"))
  16.     implicit def toy2Bird(toyBird: ToyBird)= new Bird("玩具鸟")
  18.     bitBird[ToyBird](new ToyBird)
  19.   }
  20. }
复制代码
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4