JavaScala的隐式转换详解

package com.bjsxt.scala
 
 
object ImplicitValue {
  
 
    //   * 4.一个方法如果有多个参数，要实现部分参数的隐式转换，
    //   必须使用柯里化这种方式，隐式关键字出现在后面，只能出现一次
  def Student(age:Int)(implicit name:String,i:Int) = {
    println(s"student = $name,age = $age,score = $i")
  }
  
  //   * 3.一个方法只有一个参数是隐式转换参数时，那么可以直接定义implicit关键字修饰的参数，
  //   调用时直接创建类型不传入参数即可。
  def Teacher(implicit name:String) = {
    println(s"teacher name is =$name")
  }
  def main(args: Array[String]): Unit = {
    //   * 1.同类型的参数的隐式值只能在作用域内出现一次，
    //   同一个作用域内不能定义多个类型一样的隐式值。比如这里的String、Int类型，各自只能定义一个
    implicit val name:String = "zhangsan"
    implicit val i:Int = 100
 
    //这里使用了隐式参数，只用传入age那个参数，后面两个参数可以不填，默认使用隐式值
    Student(100)
    //这里是直接使用了隐式值，可以不填参数，当然也可以给定参数，给定参数的话就是取给的参数的值
    Teacher
  }
}

student = zhangsan,age = 100,score = 100
teacher name is =zhangsan

package com.bjsxt.scala
 
class Animal(name:String){
  def canFly()= {
    println(s"$name can fly....")
  }
}
 
class Rabbit(xname:String){
  val name = xname
}
 
object ImplicitValue2 {
  
  //定义隐式转换函数
  implicit def RabbitToAnimal(r:Rabbit):Animal = {
    new Animal(r.name)
  }
  //注意隐式转换函数只与参数类型和返回值类型有关，
  // 与函数名无关，所以不能定义两个相同类型的函数，虽然函数名不同，下面这个就是非法的
//  implicit def Rabbit(r:Rabbit):Animal = {
//    new Animal(r.name)
//  }
 
  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit("rabbit")
    //这里rabbit调用不了canFly，因为Rabbit类中没有canFly方法，
    // 但定义了隐式转换函数，那就会往Animal类中找
    rabbit.canFly()
  }
}

rabbit can fly....

package com.bjsxt.scala
//隐式类
 
class Rabbit1(xname:String){
  val name = xname
}
 
object ImplicitValue3 {
 
  //定义隐式类，只能在object中定义，并且只能传入一个参数
  //不能出现同类型构造的隐式类。（同类型：参数类型和返回值类型，与类名无关）
  implicit class Animal1(r:Rabbit1){
    def showName() = {
      println(s"${r.name} is Rabbit....")//对象.属性需要加“{}”
    }
  }
 
  def main(args: Array[String]): Unit = {
    val rabbit = new Rabbit1("RABBIT")
//    Rabbit1类中没有showName方法，这是会找隐式类
    rabbit.showName()
  }
 
}

RABBIT is Rabbit....