Scala之类型参数和对象

Posted 2020-08-21

1. 泛型
2. 类型边界
3. 视图界定
4. 逆变和协变
5. 上下文界定
6. 源代码

1.泛型

泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效地增强程序的适用性，

使用泛型可以使得类或方法具有更强的通用性。

在Scala中用方括号来定义类型参数，即用[]表示，

如 class Pair[T, S](val first, val)

以上将定义一个带有两个类型参数T和S的类，带有类型参数的类是泛型的。如果把类型参数替换成实际的类型将得到普通的类。

*简单理解就是类型或者方法后面加个中括号就表示是泛型了，它可以放入任何类型，在实际实例化的时候指定具体的类型。*

2.类型边界

上边界：表达了泛型的类型必须是某种类型或者某种类的子类，语法为`<:`,例如T <: AnyVal表示泛型T的类型的最顶层类是AnyVal。

下边界：表达了泛型的类型必须是某种类型或者某种类的父类，语法为`>:`,例如T >: S表示泛型T的类型必须是S的超类，下界的作用主要是保证类型安全。

3.视图界定

如果希望类型变量界定能跨越类继承层次结构时，可以使用视图界定来实现的，

其后面的原理是通过隐式转换来实现。视图界定利用<%符号来实现，例如后面的例子[T <% Person]，

T是Person继承的或者是能变成Person。

4.逆变和协变

逆变和协变最容易理解的便是用List来理解。

协变定义形式如：trait List[+T] {} 。当类型S是类型A的子类型时，则List[S]也可以认为是List[A}的子类型，

即List[S]可以泛化为List[A]。

逆变定义形式如：trait List[-T] {}

当类型S是类型A的子类型，则Queue[A]反过来可以认为是Queue[S}的子类型。

5.上下文界定

上下文界定的类型参数形式为T：M的形式，其中M是一个泛型，这种形式要求存在一个M[T]类型的隐式值。

6.源代码

  1 package com.dtspark.scala.basics
  2 
  3  
  4 
  5 /**
  6 
  7   * Scala类型系统编程实战：
  8 
  9   * 1，Scala的类和方法、函数都可以是泛型，在Spark源码中可以到处看到类和方法的泛型，在实际实例化的时候指定具体
 10 
 11   * 的类型，例如Spark最核心、最基础、最重要的抽象数据结构RDD里面关于RDD的类的定义是泛型的，RDD的几乎所有方法
 12 
 13   * 的定义也都是泛型的，之所以这么做，是因为RDD会派生很多子类，通过子类适配了各种不同的数据源以及业务逻辑操作；
 14 
 15   * 2， 关于对类型边界的限定，分为上边界和下边界：
 16 
 17   * 上边界：表达了泛型的类型必须是某种类型或者某种类的子类，语法为<:,这里的一个新的现象是对类型进行限定；
 18 
 19   * 下边界：表达了泛型的类型必须是某种类型或者某种类的父类，语法为>:;
 20 
 21   * 3, View Bounds,可以进行某种神秘的转换，把你的类型可以在没有知觉的情况下转换成为目标类型，其实你可以认为 View Bounds是
 22 
 23   * 上边界和下边界的加强补充版本，例如在SparkContext这个Spark的核心类中有T <% Writable方式的代码，这个代码所表达的是
 24 
 25   * T必须是Writable类型的，但是T有没有直接继承自Writable接口，此时就需要通过“implicit”的方式来实现这个功能；
 26 
 27   * 4, T: ClassTag,例如Spark源码中的RDD class RDD[T: ClassTag] 这个其实也是一种类型转换系统，只是在编译的时候类型信息不够，
 28 
 29   * 需要借助于JVM的runtime来通过运行时信息获得完整的类型信息，这在Spark中是非常重要的，因为Spark的程序的编程和运行是区分了
 30 
 31   * Driver和Executor的，只有在运行的时候才知道完整的类型信息。
 32 
 33   * 5, 逆变和协变；-T和+T
 34 
 35   * 6, Conext Bounds,T: Ordering这种语法必须能够编程Ordering[T]这种方式；
 36 
 37   */
 38 
 39  
 40 
 41  
 42 
 43 class Engineer
 44 
 45  
 46 
 47 class Expert extends Engineer
 48 
 49  
 50 
 51 //class Meeting[-T]
 52 
 53 class Meeting[+T]
 54 
 55  
 56 
 57 class Animal[T](val species: T) {
 58 
 59   def getAnimal(specie: T): T = species
 60 
 61 }
 62 
 63  
 64 
 65 class Maximum[T: Ordering](val x: T, val y: T) {
 66 
 67  
 68 
 69   def bigger(implicit ord: Ordering[T]) = {
 70 
 71     if (ord.compare(x, y) > 0) x else y
 72 
 73   }
 74 
 75  
 76 
 77 }
 78 
 79  
 80 
 81 object HelloScalaTypeSystem {
 82 
 83  
 84 
 85   def main(args: Array[String]): Unit = {
 86 
 87     println("=============上界===================")
 88 
 89     //创建Person,Worker两对象，从[T <: Person]来看要传入的参数是Person的本类或子类
 90 
 91     val p = new Person("Scala")
 92 
 93     val w = new Worker("Spark")
 94 
 95     //这里传入的参数满足要求，故能直接调用comunicate
 96 
 97     new Club1(p, w).comunicate
 98 
 99     println("=============视图界定===================")
100 
101     //Person,Worker是有继承结构的，而Dog狗与人是没有的，但是又想使用comunicate方法，怎么办？
102 
103     //答案就是让狗与人隐式的发生关系让狗可以变成人！
104 
105     val dog = new Dog("dahuang")
106 
107     //看见Club2[T <% Person]可知，传入的参数要是人（有继承结构）或者能变成人，
108 
109     //当传入狗时，会去找有没有狗变成人的方法
110 
111     implicit def dog2Person(dog: Dog) = new Person(dog.name)//找到了
112 
113     new Club2[Person](w, dog).comunicate//满足了要求，可以调用comunicate
114 
115     println("=============协变===================")
116 
117     val e = new Meeting[Engineer]
118 
119     participateMeeting(e)
120 
121     val expert = new Meeting[Expert]
122 
123     participateMeeting(expert)
124 
125     println("=============上下文界定===================")
126 
127     //因为[T: Ordering]，所以传入的参数为Ordering[T]，是可以比较的，所以调用
128 
129     //bigger(implicit ord: Ordering[T])方法，而方法参数是隐式参数就可以直接运行方法体内容，
130 
131     //由于存在Ordering[T]，所以有compare方法，直接调用，返回x或y
132 
133     println(new Maximum("Scala", "Java").bigger)
134 
135   }
136 
137  
138 
139   /**
140 
141     * 传入参数类型为Meeting[Engineer]，而class Meeting[+T]，所以传入的参数可以是有继承结构的参数
142 
143     */
144 
145   def participateMeeting(meeting: Meeting[Engineer]) {
146 
147     println("Welcome")
148 
149   }
150 
151  
152 
153  
154 
155   class Person(val name: String) {
156 
157     def talk(person: Person) {
158 
159       println(this.name + " : " + person.name)
160 
161     }
162 
163   }
164 
165  
166 
167   class Worker(name: String) extends Person(name)
168 
169  
170 
171   class Dog(val name: String)
172 
173  
174 
175   class Club1[T <: Person](p1: T, p2: T){
176 
177     def comunicate = p1.talk(p2)
178 
179   }
180 
181  
182 
183   class Club2[T <% Person](p1: T, p2: T) {
184 
185     def comunicate = p1.talk(p2)
186 
187   }
188 
189  
190 
191 }
192 
193