（大数据开发随笔5）Scala编程语言基础——泛型

泛型

泛型类

// 创建一个通用类，技能操作Int类型，又能操作String类型
class GenericClass[T] {
    private var content:T = _ // 泛型
    
    def set(value:T) = {content = value}
    def get():T= {content}
}

object GenericClass{
    def main(arg: Array[String]): Unit = {
        // Int类型
        var intGeneric = new GenericClass[Int]
        intGeneric.set(123)
        println(intGeneric.get()) // 123
        // String类型
        var stringGeneric = new GenericClass[String]
        stringGeneric.set("hello scala")
        println(stringGeneric.get()) // 'hello scala'
    }
}

泛型函数

• 在泛型函数中，T必须是ClassTag类型
• ClassTag表示执行Scala程序时的运行信息；在下例中，表示数据的类型

import scala.reflect.ClassTag
// 创建一个通用函数，既能创建Int类型数组，又能创建String类型数组
def mkArray[T:ClassTag](elems:T*) = Array[T](elems:_*)
mkArray(1,2,3)
mkArray('a','b','c')

上界、下界

• 规定泛型的取值范围
• 假设继承关系：（父）A —> B —> C —> D（子），则，D <: y泛型 <: B 表示，y的类型只能是B、C、D
• 定义：
  • 上界：S <: T，表示S的类型必须是T的子类
  • 下界：U >: T，表示U的类型必须是T的父类

// 上界举例
// 父类
class Vehicle{
    def drive() = {println("Driving")}
}

// 子类一
class Car extends Vehicle{
    override def drive(): Unit = {println("Car Driving")}
}
// 子类二
class Bike extends Vehicle{
    override def drive(): Unit = {println("Bike Driving")}
}

// 其他类
class Apple

object ScalaUpperBound{
    // 定义一个泛型函数
    def takeVehicle[T <: Vehicle(v:T)] = {v.drive()}
    
    def main(args: Array[String]): Unit = {
        var v1:Vehicle = new Vehicle
        var v2:Car = new Car
        var v3:Apple = new Apple
        
        takeVehicle(v1) // 正常
        takeVehicle(v2) // 正常
        takeVehicle(v3) // 异常
    }
}

视图界定

• 上下界的扩展，适用范围更广泛
• 以上界为例 <:
  • 除了接收所有的子类，还允许接受隐式转换过去的类型
  • 需要定义转化规则（隐式转换函数）

// 普通上下界
def addTwoString[T <: String](x:T, y:T) = {println(x + y)}

addTwoString("hello", "world") 
addTwoString(100, 200) // 异常

// 视图界定
implicit def int2String(n:Int):String = {n.toString}
def addTwoString[T <% String](x:T, y:T) = {println(x + y)}
// T表示的类型：
// (1) String和String的子类
// (2) 可以转换成String类型的类型

addTwoString("hello", "world") 
addTwoString(100, 200) // 正常 100200

协变和逆变

• 可以看作是视图界定的一个扩展
• 缺点：降低了代码的可读性
• 协变：若一个泛型类接受的泛型参数可以是本身的类型或子类的类型
  • 在泛型前加+

// 协变

// 动物
class Animal

// 子类：鸟
class Bird extends Animal

// 子类：麻雀
class Sparrow extends Bird

// 类：吃
class EatSomething[+T](t:T){} // 在T之前加`+`后，下面的问题就没有了

object Demo{
    def main(args: Array[String]): Unit = {
        // 鸟吃东西的对象
        var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)
        
        // 动物吃东西的对象
        // 方法一
        // var c2:EatSomething[Animal] = new EatSomething[Animal](new Animal)
        // 方法二：将c1付给c2
        // 问题：尽管Bird是Animal的子类，但EatSomething[Bird]不是EatSomething[Animal]的子类
        var c2:EatSomething[Animal] = c1
        
        var c3:EatSomething[Sparrow] = new EatSomething[Sparrow](new Sparrow)
        var c4:EatSomething[Animal] = c3
    }
}

• 逆变：若一个泛型类接受的泛型参数可以是本身的类型或父类的类型
  • 在泛型前加-

// 逆变

// 动物
class Animal

// 子类：鸟
class Bird extends Animal

// 子类：麻雀
class Sparrow extends Bird

// 类：吃
class EatSomething[-T](t:T){} // 在T之前加`-`后，下面的问题就没有了

object Demo2{
    def main(args: Array[String]): Unit = {
        // 鸟吃东西的对象
        var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)
        
        // 麻雀吃东西的对象
        // 方法一
        // var c2:EatSomething[Sparrow] = new EatSomething[Sparrow](new Sparrow)
        // 方法二：将c1付给c2
        // 问题：尽管Bird是Sparrow的父类，但EatSomething[Bird]不是EatSomething[Sparrow]的父类
        var c2:EatSomething[Sparrow] = c1
    }
}

隐式转换函数

• 函数前加implicit

// 水果
class Fruit(name:String){
    def getFruitName():String = {name}
}

// 猴子
class Monkey(f:Fruit){
    def say() = {println("Monkey like " + f.getFruitName())}
}


object ImplicitDemo{
    // 定义隐式转换函数：Fruit对象 ==> Monkey对象
    implicit def fruit2Monkey(f:Fruit): Monkey = {new Monkey(f)}
    
    def main(args: Array[String]): Unit = {
        var f:Fruit = new Fruit("香蕉")
        // 将Fruit的对象转换成Monkey的对象
        f.say() // "Monkey like 香蕉"
    }
}

隐式参数

• 变量前加implicit

def testParam(implicit name:String) = {println("The value is " + name)}

// 定义隐式参数
implicit val name:String = "这是一个隐式参数"
// 调用，且不传递参数
testParam // 程序在运行时会检查当前有没有类型为String的name，如果有则自动将该参数传入函数

隐式类

• class前加implicit
• 作用：对类的功能进行加强

object ImplicitDemo2{
    // 定义隐式类
    implicit class Calculate(x:Int){
        def add(y:Int) = x + y
    }
    
    def main(args: Array[String]): Unit = {
        // 进行两个数的相加 1.add(2)
        println(1.add(2)) // 3
        // 顺序：
        // 先调用隐式转换类，把 1 ==> Calculate对象
        // 再调用Calculate对象的add方法
    }
}