1.隐式转换

1.1 什么是隐式转换？

看如下示例

object Scala_Transform {  def main(args: Array[String]): Unit = {    val byte_num:Byte = 21    val int_num:Int = byte_num    println(int_num)  }}

这个可能失常打印，因为可能编译器可能进行主动转换，但如果代码改货色，由int转换成byte

object Scala_Transform {  def main(args: Array[String]): Unit = {    val int_num:Int = 21    val byte_num:Byte = int_num //这里会出错    println(byte_num)  }}

出错起因由Int到Byte没有间接的关系，编译器找不到对应的转换方法。
那么咱们提供一个

object Scala_Transform {  def main(args: Array[String]): Unit = {    // int转换成byte的办法    def itbFun(x:Int):Byte = {      x.toByte    }    val int_num:Int = 21    val byte_num:Byte = itbFun(int_num)//这里会出错    println(byte_num)  }}

然而这样又批改了代码逻辑，那么是否让编译器本人找到转换方法来进行转换呢？这时候只有在办法前加上一个关键字implicit

object Scala_Transform {  def main(args: Array[String]): Unit = {    // int转换成byte的办法    implicit def itbFun(x:Int):Byte = {      x.toByte    }    val int_num:Int = 21    val byte_num:Byte = int_num    println(byte_num)  }}

编译就会主动找到转换的办法，来进行转换，这个就是隐式转换。

1.2 隐式办法

在函数申明前减少implicit关键字，编译器就能自动识别和主动调用实现类型的转换，这样的办法就叫隐式办法。

object Scala_Transform {  def main(args: Array[String]): Unit = {    val person = new Person    person.info()        // 因为需要变动，咱们须要在原有信息打印根底上加上性别地址address信息    // 咱们能够应用隐式办法来实现这个    implicit def transformFun(person: Person): PersonInfoAdd ={      new PersonInfoAdd    }    person.updateInfo()      }    class Person {    def info(): Unit ={      println("name：xxx age:xxx")    }  }    // 扩大类  class PersonInfoAdd{    def updateInfo():Unit = {      println("address:xxxx")    }  }  }

在应用时须要留神，以后范畴内，雷同的转换规则只能有一个。
隐式转换方法会在第一次编译出错时，抉择隐式转换，所以也叫二次编译。

1.3 隐士参数和隐士变量

implicit除了润饰办法外，还能够润饰参数，这个就是隐式参数。
当咱们事后晓得办法的参数会发生变化时，咱们能够应用implicit要害来润饰的这个参数。
隐士变量，就是编译器主动找到并传递的参数值
示例

object Scala_Transform {  def main(args: Array[String]): Unit = {    // 登录账号，最开始应用默认明码123456登录，前期应用用户自定义的明码登录    def loginFun(user:String)(implicit pwd:String="123456"): Unit ={      println(s"用户:$user, 明码:$pwd")    }    // 隐士变量    implicit val pwd:String = "123123"    // 应用隐士参数时，前面省略小括号    loginFun("user1") // 输入后果  用户:user1, 明码:123123    // 不省略小括号，会传递默认值或者自定义参数，而不应用隐式变量    loginFun("user1")() // 输入后果 用户:user1, 明码:123456    loginFun("user1")("666666") // 输入后果 用户:user1, 明码:666666  }}

1.4 隐士类

隐式类是2.10版本减少的
示例

object Scala_Transform {  def main(args: Array[String]): Unit = {    val person = new Person    person.info()    person.updateInfo()   // 隐士类的查找程序   // 1)第一个是以后作用域   // 2)下级作用域   // 3)以后类所在的包对象   // 4)父类   // 5)特质      // 个别咱们应用隐士类转换时，能够间接导入     }  class Person {    def info(): Unit ={      println("name：xxx age:xxx")    }  }  // 隐式类  // implicit润饰，结构参数要存在且只有一个，用于类型转换  implicit class PersonInfoAdd(person: Person){    def updateInfo():Unit = {      println("address:xxxx")    }  }}

2.泛型

2.1 Scala泛型

泛型用于指定办法或类能够承受任意类型参数，参数在理论应用时才被确定，泛型能够无效地加强程序的适用性，应用泛型能够使得类或办法具备更强的通用性。
Scala中泛型和Java泛型统一，但性能更加弱小，申明时应用[]

2.2 泛型类、泛型办法

泛型类：指定类能够承受任意类型参数。
泛型办法：指定办法能够承受任意类型参数。

示例

object Scala_Generic {  def main(args: Array[String]): Unit = {      }  // 应用[]申明泛型  class DemoClass[T] {    private val list:List[T] = Nil  }}

2.3 泛型转换

2.3.1 泛型不可变

示例

object Scala_Generic {  def main(args: Array[String]): Unit = {    // 泛型不可变    val demo1:Demo[Student] = new Demo[Student] // 正确    val demo2:Demo[Student] = new Demo[Person] //谬误    val demo3:Demo[Student] = new Demo[Student_Of_BJ] //谬误        // 从后果上看，在咱们惯例申明，没有采纳其余路径时，泛型是不可变的  }  class Demo[T] {  }  class Person{  }  class Student extends Person{  }  class Student_Of_BJ extends Student{  }}

2.3.2 泛型协变

Scala能够让下面代码 "val demo3:Demo[Student] = new Demo[Student_Of_BJ]" 可能通过的，也就是说，泛型能够将子类型当成父类型应用，这个是泛型的协变
示例代码

object Scala_Generic {  def main(args: Array[String]): Unit = {    // 泛型协变    val demo1:Demo[Student] = new Demo[Student] // 正确    val demo2:Demo[Student] = new Demo[Person] //谬误    val demo3:Demo[Student] = new Demo[Student_Of_BJ] //正确  }  // 非常简单，只有在泛型前用"+"  class Demo[+T] {  }  class Person{  }  class Student extends Person{  }  class Student_Of_BJ extends Student{  }}

2.3.4 泛型逆变

泛型能够将父类型当成子类型应用，应用[-T] 申明泛型

object Scala_Generic {  def main(args: Array[String]): Unit = {    // 泛型逆变    val demo1:Demo[Student] = new Demo[Student] // 正确    val demo2:Demo[Student] = new Demo[Person] // 正确    val demo3:Demo[Student] = new Demo[Student_Of_BJ] //谬误      }  // 加个减号即可  class Demo[-T] {  }  class Person{  }  class Student extends Person{  }  class Student_Of_BJ extends Student{  }}

2.3.5 泛型的下限与上限

在指定泛型类型时，有时须要界定泛型类型的范畴，而不是接管任意类型。
Scala的高低边界个性容许泛型类型是某个类的子类，或者是某个类的父类；
(1) U >: T
这是类型下界的定义，也就是U必须是类型T的父类(或自身，本人也能够认为是本人的父类)。
(2) S <: T
这是类型上界的定义，也就是S必须是类型T的子类（或自身，本人也能够认为是本人的子类)。

示例

object Scala_Generic {  def main(args: Array[String]): Unit = {  }  class Person{  }  class Student extends Person{  }  class Student_Of_BJ extends Student{  }    class Demo{    // 泛型下限    def fun1[T<:Student](t:T)= {}    // 泛型上限    def fun2[T>:Student](t:T)= {}  }}