Scala泛型和上下界

[toc]

## Scala泛型和上下界

### 1. Scala泛型

> 1. 如果我们要求函数的参数可以接受任意类型。可以使用`泛型`，这个类型可以代表任意的数据类型。
> 2. 例如 List，在创建 List 时，可以传入整型、字符串、浮点数等等任意类型。那是因为 List 在 类定义时引用了泛型。`比如在Java中：public interface List<E> extends Collection<E>`

#### Scala泛型案例一

> 1. 编写一个Message类
> 2. 可以构建Int类型的Message，也可以构建String类型的Message。
> 3. 要求使用泛型来完成设计(说明：不能使用Any)

```scala
/**
* @Date 2021/4/5 18:25
* @Version 10.21
* @Author DuanChaojie
*/
object GenericDemo01 {
def main(args: Array[String]): Unit = {
val message1 = new Message[Int](10)
val message2 = new Message[String]("str")
println(message1.toString())
println(message2.toString())
}
}

class Message[T](inMes: T) {
var mes = inMes
override def toString = {
"重写的toString方法...." + mes
}
}
```

#### Scala泛型案例二

> 1. 请设计一个`EnglishClass` (英语班级类)，在创建EnglishClass的一个实例时，需要指定`[ 班级开班季节(spring,autumn,summer,winter)、班级名称、班级类型]`
> 2. 开班季节只能是指定的，班级名称为String，班级类型是(字符串类型 "高级班", "中级班", "初级班") 或者是 Int 类型(1, 2, 3 等)
> 3. 请使用泛型来完成本案例
> 4. [Scala枚举详解...](https://pedrorijo.com/blog/scala-enums/)

~~~~scala
package com.atguigu.chapter16

import com.atguigu.chapter16.SeasonEnum.SeasonEnum

/**
* @Date 2021/4/5 18:32
* @Version 10.21
* @Author DuanChaojie
*/
object GenericDemo02 {
def main(args: Array[String]): Unit = {
val scalaClass = new EnglishClass[String, Int, String]("春天", 4, "Scala班")
println(scalaClass.toString())

val javaClass = new EnglishClass[SeasonEnum, String, String](SeasonEnum.spring, "Java", "5班")
println(javaClass.toString)
}
}

class EnglishClass[A, B, C](inSeason: A, inClassName: B, inClassType: C) {
var season: A = inSeason
var className: B = inClassName
var classType: C = inClassType

override def toString: String = {
s"season = $season\nclassType = $classType\nclassName = $className 班"
}
}

/**
* 枚举类SeasonEnum
*/
object SeasonEnum extends Enumeration {
type SeasonEnum = Value
val spring, summer, autumn, winter = Value
}
~~~~

#### Scala泛型案例三

> 1. 定义一个函数，可以获取各种类型的 List 的中间index的值
> 2. 使用泛型完成

~~~~scala
/**
* @Date 2021/4/5 19:21
* @Version 10.21
* @Author DuanChaojie
*/
object GenericDemo03 {
def main(args: Array[String]): Unit = {
val list1 = List[String]("dd", "ai", "mm")
val list2 = List[Int](1, 2, 3)
println(midValue(list1))
println(midValue(list2))
}

def midValue[T](list: List[T]): T = {
list(list.length / 2)
}
}
~~~~

### 2. Scala类型约束

#### 测试上下界用到的公共类

~~~~scala
package com.atguigu.chapter16

/**
* @Date 2021/4/5 20:03
* @Version 10.21
* @Author DuanChaojie
*/
object BoundsCommonClass {
// Scala上界和下界测试用到的类
}

/**
* Earth 类
*/
class Earth {
def sound() {
println("hello Earth !")
}
}

/**
* Animal类
*/
class Animal extends Earth {
//重写了Earth的方法sound()
override def sound() = {
println("animal sound")
}
}

/**
* Bird类
*/
class Bird extends Animal {
// 将Animal的方法重写
override def sound() = {
println("bird sounds")
}
}

class Moon{
def sound() = {
println("Moon Moon ~")
}
}

class MyCat(val name: String, val age: Int) {
override def toString: String = {
s"name = $name \nage = $age"
}
}
~~~~

#### 上界(Upper Bounds)

> ==Java中上界：==在 Java 泛型里表示某个类型是 A 类型的子类型，使用 extends 关键字，这种形式叫 `upper bounds(上限或上界)`，语法如下：

~~~~java
<T extends A>
//或用通配符的形式：
<? extends A>
~~~~

> ==Scala中上界：==在 Scala 里表示某个类型是 A 类型的子类型，也称上界或上限，使用 `<: 关键字`，语法如下：

~~~scala
[T <: A]
//或用通配符:
[_ <: A]
~~~

> Scala上界应用案例：
>
> 1. 编写一个通用的类，可以进行Int之间、Float之间、等实现了Comparable接口的值直接的比较。
> 2. 分别使用传统方法和上界的方式来完成，体会上界使用的好处。
> 1. 传统方法：`class MyCompare1(inX: Int, inY: Int){...}`
> 2. 使用上界：`class MyCompare2[T <: Comparable[T]](inX: T, inY: T) {...}`

~~~~scala
package com.atguigu.chapter16

/**
* @Date 2021/4/5 19:27
* @Version 10.21
* @Author DuanChaojie
*/
object UpperBoundsDemo01 {
def main(args: Array[String]): Unit = {
val myCompare1 = new MyCompare1(8, 9)
println(myCompare1.max)

/**
* 注意Scala中Int不是Comparable的子类
*/
val myCompare2 = new MyCompare2[Integer](8, 9)
println(myCompare2.max)
val myCompare22 = new MyCompare2[java.lang.Float](8.4f, 8.6f)
println(myCompare22.max)
}
}

/**
* 传统方式解决
*
* @param inX
* @param inY
*/
class MyCompare1(inX: Int, inY: Int) {
var x = inX
var y = inY

def max = if (x > y) x else y
}

/**
* 使用Scala上界来完成
* 1. [T <: Comparable[T]] 表示T类型是Comparable 子类型
* 2. 即你传入的T类要继承Comparable接口
* 3. 这样就可以使用compareTo方法
* 4. 这样的写法(使用上界的写法)通用性比传统的好
*/
class MyCompare2[T <: Comparable[T]](inX: T, inY: T) {
var x = inX
var y = inY

/**
* x.compareTo(y) 将此对象与指定对象进行比较。
* 负数---> x < y
* 0 ---> x == y
* 正数---> x > y
*/
def max = if (x.compareTo(y) > 0) x else y
}
~~~~

> Scala中上界课程测试题(理解上界含义)
>
> - `案例中使用到的类，见BoundsCommonClass.scala`

~~~~scala
package com.atguigu.chapter16

/**
* @Date 2021/4/5 19:49
* @Version 10.21
* @Author DuanChaojie
*/
object UpperBoundsDemo02 {
def main(args: Array[String]): Unit = {
getSound(Seq(new Bird,new Bird))
println("-----------")
getSound(Seq(new Animal,new Animal))
println("-----------")
getSound(Seq(new Bird,new Animal))
println("-----------")
//getSound(Seq(new Earth,new Earth)) 报错，因为Earth不是Animal的子类
//getSound(Seq(new Moon)) 报错
}

def getSound[T <: Animal](seq: Seq[T]) = {
seq.map(_.sound())
}
}
~~~~

#### 下界(lower bounds)

> ==Java中下界：==在 Java 泛型里表示某个类型是 A类型的父类型，使用 `super 关键字`，语法如下：

~~~~java
<T super A>
//或用通配符的形式：
<? super A>
~~~~

> ==Scala中下界：==在 Scala 的下界或下限，使用 `>: 关键字`，语法如下：

~~~~scala
[T >: A]
//或用通配符:
[_ >: A]
~~~~

> Scala中下界应用实例

~~~~scala
/**
* @Date 2021/4/5 20:01
* @Version 10.21
* @Author DuanChaojie
*/
object LowerBoundsDemo01 {
def main(args: Array[String]): Unit = {
getSound(Seq(new Earth,new Earth)).map(_.sound())
println("-------------------")
getSound(Seq(new Animal,new Animal)).map(_.sound())
println("-------------------")
// 可以使用，而且打印的是bird sounds，原因见小结
getSound(Seq(new Bird,new Bird)).map(_.sound())
println("-------------------")
val seq = getSound(Seq(new Moon)) // seq是Object类型的
// val moon = seq.asInstanceOf[Moon] 报错
// moon.sound()
}

def getSound[T >: Animal](seq: Seq[T]) = seq
}
~~~~

> Scala中下界的使用小结：
>
> 1. 对于下界，可以传入任意类型。
> 2. `传入和Animal直系的，是Animal父类的还是父类处理，是Animal子类的按照Animal处理。`
> 3. `和Animal无关的，一律按照Object处理。`
> 4. 也就是下界，可以随便传，只是处理是方式不一样。
> 5. 不能使用上界的思路来类推下界的含义。

#### 视图界定

> 1. `<% 的意思是“view bounds”(视界)，它比<:适用的范围更广，除了所有的子类型，还允许隐式转换类型。`
> 2. 视图界定应用案例：
> 3. 使用视图界定的方式，比较两个Person对象的年龄大小。

~~~scala
/**
* @Date 2021/4/5 20:16
* @Version 10.21
* @Author DuanChaojie
*/
object ViewBoundsDemo01 {

// 隐士函数
implicit def MyImplicit(cat: MyCat) = new Ordered[MyCat] {
override def compare(that: MyCat) = {
cat.age - that.age
}
}

def main(args: Array[String]): Unit = {
val tom = new MyCat("tom", 18)
val jack = new MyCat("jack", 2)

val myCompare3 = new MyCompare3(tom, jack)
println(myCompare3.max)
}
}

 

/**
* Ordered和Ordering的区别？
* Ordering中的方法：def compare(x: T, y: T): Int
* Orderd中有这个方法： def compareTo(that: A): Int = compare(that)
* 1. T <% Ordered[T] 表示T是Ordered子类型 java.lang.Comparable
* 2. 这里调用的compareTo方法是 T这个类型的方法
*/
class MyCompare3[T <% Ordered[T]](x: T, y: T) {
def max = if (x.compareTo(y) > 0) x else y
}
~~~

#### 上下文界定

> 1. 与 view bounds 一样 context bounds(上下文界定)也是隐式参数的语法糖。为语法上的方便， 引入了”上下文界定”这个概念。
> 2. 上下文界定应用实例
> 1. 使用上下文界定+隐式参数的方式，比较两个Person对象的年龄大小
> 2. 使用Ordering实现比较。

~~~~scala
package com.atguigu.chapter16

/**
* @Date 2021/4/5 20:53
* @Version 10.21
* @Author DuanChaojie
*/
object ContextBoundsDemo01 {
/**
* 这里我定义一个隐式值 Ordering[MyCat]类型
*/
implicit val catComparetor = new Ordering[MyCat] {
override def compare(cat1: MyCat, cat2: MyCat): Int =
cat1.age - cat2.age
}

def main(args: Array[String]): Unit = {
val tom = new MyCat("tom", 18)
val jack = new MyCat("jack", 2)
val myCompare4 = new MyCompare4(tom, jack)
println(myCompare4.max)

println("-----------------")
val myCompare5 = new MyCompare5(tom, jack)
println(myCompare5.max)
println("-----------------")
val myCompare6 = new MyCompare6(tom, jack)
println(myCompare6.max)
}
}

/**
* 方式1
* 1. [T: Ordering] 泛型
* 2. o1: T, o2: T 接受T类型的对象
* 3. implicit comparetor: Ordering[T] 是一个隐式参数
*/
class MyCompare4[T: Ordering](o1: T, o2: T)(implicit comparetor: Ordering[T]) {
def max = if (comparetor.compare(o1, o2) > 0) o1 else o2
}

/**
* 方式2,将隐式参数放到方法内
*/
class MyCompare5[T: Ordering](o1: T, o2: T) {
def max = {
//返回一个数字
def fun(implicit comparetor: Ordering[T]) = comparetor.compare(o1, o2)
//如果f1返回的值>0,就返回o1,否则返回o2
if (fun > 0) o1 else o2
}

def lowwer = {
def f1(implicit cmptor: Ordering[T]) = cmptor.compare(o1, o2) //返回一个数字
//如果f1返回的值>0,就返回o1,否则返回o2
if (f1 > 0) o2 else o1
}
}

/**
* 方式3,使用implicitly语法糖，最简单(推荐使用)
*/
class MyCompare6[T: Ordering](o1: T, o2: T) {
def max = {
/**
* 这句话就是会发生隐式转换，获取到隐式值 personComparetor
* 底层仍然使用编译器来完成绑定(赋值的)工作
*/
val comparetor = implicitly[Ordering[T]]
//println("comparetor hashcode=" + comparetor.hashCode())
if (comparetor.compare(o1, o2) > 0) o1 else o2
}
}
~~~~

### 3. Scala协变、逆变和不变

> 1. `Scala的covariant协变(+)，contravariant逆变(-)，不可变invariant。`
> 2. 在Java里，泛型类型都是invariant，比如 List<String> 并不是 List<Object> 的子类型。而Scala支持，可以在定义类型时声明(用加号表示为协变，减号表示逆变)，如: trait List[+T] // 在类型定义时声明为协变这样会把List[String]作为List[Any]的子类型。

#### 应用实例

> 在这里引入关于这个符号的说明，在声明Scala的泛型类型时，`“+”表示协变，而“-”表示逆变`
>
> 1. `C[+T]：如果A是B的子类，那么C[A]是C[B]的子类，称为协变`
> 2. `C[-T]：如果A是B的子类，那么C[B]是C[A]的子类，称为逆变`
> 3. `C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。称为不变。`

~~~~scala
package com.atguigu.chapter16

/**
* @Date 2021/4/5 21:13
* @Version 10.21
* @Author DuanChaojie
*/
object LastDemo01 {
/**
* C[+T]：如果A是B的子类，那么C[A]是C[B]的子类，称为协变 
* C[-T]：如果A是B的子类，那么C[B]是C[A]的子类，称为逆变 
* C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。称为不变
*/
def main(args: Array[String]): Unit = {

val t4: Temp4[Super] = new Temp4[Sub]("hello"); //协变

val t5: Temp5[Sub] = new Temp5[Super]("hello"); //逆变

val t6: Temp6[Sub] = new Temp6[Sub]("hello"); //不变

}
}

//协变
class Temp4[+A](title: String) {
override def toString: String = {
title
}
}

//逆变
class Temp5[-A](title: String) {
override def toString: String = {
title
}
}

//不变
class Temp6[A](title: String) {
override def toString: String = {
title
}
}

// 支持协变
class Super

//Sub是Super的子类
class Sub extends Super
~~~~

## ☆