[Scala] 高级特性

泛型

• 泛型类

package day0603

class GenericClassInt {
  private var content:Int=10
  def set(value:Int)={content=value}
  def get():Int={content}
}

class GenericClassString {
  private var content:String=""
  def set(value:String)={content=value}
  def get():String={content}
}

class GenericClass[T]{
  private var content:T = _
  def set(value:T) = {content=value}
  def get():T={content}
}

object GenericClass{
  def main(args: Array[String]):Unit = {
  var v1 = new GenericClass[Int]
  v1.set(1000)
  v1.get()
  
  var v2 = new GenericClass[String]
  v2.set("Hello")
  v2.get()
  }
}

• 泛型函数
  • ClassTag表示Scala在运行时的状态信息，这里表示调用时的数据类型

• 上界和下界
  • 规定泛型的取值范围
  • 上界：S <:  T 规定了S的类型必须是T的子类或者本身
  • 下界：U >:  T 规定了U的类型必须是T的父类或者本身

package day0603

class Vehicle{
  def drive()={println("Driving")}
}

class Car extends Vehicle{
  override def drive()={println("Car Driving")}
}

class Bike extends Vehicle{
  override def drive()={println("Bike Driving")}
}

object ScalaUpperBound {
  def takeVehicle[T <: Vehicle](v:T)={v.drive()}
  def main(args: Array[String]):Unit = {
    
    var v:Vehicle = new Vehicle
    takeVehicle(v)
    
    var c:Vehicle = new Car
    takeVehicle(c)
    
    //不能传递别的类型
    //takeVehicle("Hello")
  }
}

• 视图界定（View Bound）
  • 除了可以接收上界和下界规定的类型以外，还可以接收能够通过隐式转换过去的其他类型，用 % 表示
  • 首先调用int2String，把Int转为String，再调用addTwoString

• 协变和逆变
  • 协变：在类型参数的前面加 +，泛型变量的值可以是本身类型或其子类类型

package day0603.demo1

class Animal

class Bird extends Animal
class Sparrow extends Bird

class EatSomething[+T](t:T) 

object DemoClass1 {
  def main(args: Array[String]):Unit = {
  var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)
  //尽管Bird是Animal的这子类，但EatSometing[Bird]不是EatSometing[Animal]的子类
  var c2:EatSomething[Animal] = c1
  
  var c3:EatSomething[Sparrow]=new EatSomething[Sparrow](new Sparrow)
  var c4:EatSomething[Animal]=c3
  }
}

• • 逆变：在类型参数的前面加 -，泛型变量的值可以是本身类型或其父类类型

package day0603.demo2

class Animal

class Bird extends Animal
class Sparrow extends Bird

class EatSomething[-T](t:T) 

object Demo2Class {
  def main(args: Array[String]):Unit = {
  var c1:EatSomething[Bird] = new EatSomething[Bird](new Bird)
  //var c2:EatSomething[Sparrow] = new EatSomething[Sparrow](new Sparrow)
  //尽管Bird是Sparrow的父类，但EatSometing[Bird]不是EatSometing[Sparrow]的父类
  var c2:EatSomething[Sparrow] = c1
  }
}

隐式转换

• 隐式转换函数
  • 多了一个关键字implicit
  • 定义后，不需要显示调用，编译器会自动调用

package day0603

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

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

object ImplicitDemo {
  
  implicit def fruit2Monkey(f:Fruit):Monkey = {new Monkey(f)}
  
  def main(args: Array[String]):Unit = {
    var f:Fruit = new Fruit("Banana")
    
    //把Fruit转成Monkey就可调用say()
    f.say()
  }
}

Monkey like Banana

• 隐式参数
  • 调用时没有给函数传递参数值，采用隐式参数

• 隐式类
  • 可增强类的功能

object ImplicitClassDemo {
  //定义隐式类，增强对象功能
  implicit class Calc(x:Int){
    def add(y:Int):Int = x+y
  }
  
  def main(args: Array[String]):Unit = {
    println("两个数字的和是： " + 1.add(2)) // 没有add方法
  }
}

两个数字的和是： 3