Scala study notes (4) - implicit conversion

Implicit parameters:
1: keyword implicit
2: Scope: first look for global, then local
3: look for the only one that can match, if multiple conditions are met, an error will be reported.

4: Implicit needs to be used in the object

When the hermit transition occurs:
1) When an object calls a method, but the object does not have this method.

   a: Int RichInt (source)

   b：File RichFile (《快学scala》)

package day4

class MyFile(var pp:String)

class MyRichFile(var p:String){
  def path: Unit ={
    println("ok:" + p)
  }
}

object implicit_2 {
  implicit def aa(a:MyFile)=new MyRichFile(a.pp)

  def main(args: Array[String]): Unit = {
    val file = new MyFile("yes")
    file.path
  }

}

   c: superman transformation 

 

package day4

class SuperMan (var name:String,var age:Int){

}
class RichSuperMan(var name:String,var age:Int){

  def  fly: Unit ={
    println(s"name = $name and age = $age")
  }
}
object Test{
  implicit def rm(ss:SuperMan)=new RichSuperMan(ss.name,ss.age)
  def main(args: Array[String]): Unit = {

    val su = new SuperMan("zhangdan",55)
    su.fly


  }
}

2) When a method is called, this method does exist, and the stored parameter types do not match.

   a: Beijing Ticket Office

package day4.implicit_test2

class Test {

}

class Person(var name:String)

class Student( name:String) extends Person(name:String)

class Older(name :String) extends Person(name :String)

object buyticket{
  def butt(p:Student): Unit ={
    println(p.name+"got a ticket")
  }
  implicit  def aa(x:Person)=new Student(x.name)
  def main(args: Array[String]): Unit = {

    val person = new Person("zhangsan")
    val student = new Student("xiao ming")
    val older = new Older("lao wang")

//    butt(person)
    butt(older)

  }
}

3) The view boundary
   A <% B A must be a subclass of B, if not, the hermit transition will be triggered, and the transition will become B

   

package day4.implicit_test3

class Person(var name:String){
  def sayHello: Unit ={
    println(s"hello my name is $name")
  }
  def makeFriends(p:Person): Unit ={
    sayHello
    p.sayHello
  }
}
class Student (name:String) extends Person(name :String)

class Dog(var name:String)

class MakeFriends [T <% Person]{
  def paly(p1:Person,p2:Person): Unit ={
    p1.makeFriends(p2)
  }

}
object Testtt{
  implicit def dog2person(d:Dog):Person={
      new Person(d.name)
  }
  def main(args: Array[String]): Unit = {

    val dds = new Person("dds")
    val ss = new Student("ss")
    val dogDog = new Dog("dog")
    val mak = new MakeFriends[Person]
    mak.paly(dds,ss)
    mak.paly (dds, dogDog)

  }
}

Upper Bound:

   

package day4.implicit_test3

class Test1[T<:Comparable[T]] {
  def shuai(b1:T,b2:T): T ={
    if (b1.compareTo(b2) < 0)
      b1
    else
      b2
  }
}
object TTT{
  def main(args: Array[String]): Unit = {
    val zs = new Boy("zs",13)
    val ls = new Boy("ls",44)
    val p = new Test1[Boy]
    val boy = p.shuai(zs,ls)
    println(boy.name + "\t" + boy.value)
  }
}

Nether:

package day4.implicit_test3

class A (var name:String)
class B (name:String) extends A( name:String)
class C (name:String) extends B( name:String)
class D (name:String)extends C( name:String)

class GetIdCard {
  def getCard[T>:C](a:T){
    println(" you get it")
  }

}
object ttt{
  def main(args: Array[String]): Unit = {
    val card = new GetIdCard
    card.getCard[C](new C("myself"))
  }
}

Covariance:
    Participate in the League of Legends competition Parent class - "It's okay if the subclass comes.
Inversion :
    Shanghai Masters (Snooker competition) Subclass (amateur) --" The result is that the parent class (Ding Junhui) comes.

package day4.implicit_test3

class A (var name:String)
class B (name:String) extends A( name:String)
class C (name:String) extends B( name:String)
class D (name:String)extends C( name:String)

class GetIdCard {
  def getCard[T>:C](a:T){
    println(" you get it")
  }

}
object ttt{
  def main(args: Array[String]): Unit = {
    val card = new GetIdCard
    card.getCard[C](new C("myself"))
  }
}

package day4.implicit_test3

class A (var name:String)
class B (name:String) extends A( name:String)
class C (name:String) extends B( name:String)
class D (name:String)extends C( name:String)

class GetIdCard {
  def getCard[T>:C](a:T){
    println(" you get it")
  }

}
object ttt{
  def main(args: Array[String]): Unit = {
    val card = new GetIdCard
    card.getCard[C](new C("myself"))
  }
}

package day4.implicit_test3

class A (var name:String)
class B (name:String) extends A( name:String)
class C (name:String) extends B( name:String)
class D (name:String)extends C( name:String)

class GetIdCard {
  def getCard[T>:C](a:T){
    println(" you get it")
  }

}
object ttt{
  def main(args: Array[String]): Unit = {
    val card = new GetIdCard
    card.getCard[C](new C("myself"))
  }
}