So verwenden Sie die implizite Konvertierung in Java Scala

Bei der impliziten Konvertierung führt der Scala-Compiler einen Typabgleich durch. Wenn kein geeigneter Typ gefunden werden kann, kann der Compiler durch die implizite Konvertierung automatisch den entsprechenden Typ innerhalb des Bereichs ableiten.

1. Implizite Werte und implizite Parameter

Implizite Werte beziehen sich auf das Hinzufügen impliziter Werte vor Parametern bei deren Definition. Implizite Parameter bedeuten, dass beim Definieren einer Methode einige Parameter in der Methode implizit geändert werden [es muss Curry verwendet werden und die impliziten Parameter müssen am Ende in Klammern geschrieben werden]. Die Funktion der impliziten Konvertierung besteht darin, dass Sie beim Aufrufen einer Methode die impliziten Parameter in der Methode nicht manuell übergeben müssen. Scala findet den impliziten Wert automatisch im Gültigkeitsbereich und übergibt ihn automatisch.

Implizite Werte und implizite Parameter müssen die folgenden Punkte beachten:
1 Der implizite Wert desselben Parametertyps darf nur einmal im Gültigkeitsbereich vorkommen , und die gleiche Funktion Mehrere implizite Werte desselben Typs können nicht in einer Domäne definiert werden.

2. Das implizite Schlüsselwort muss am Anfang der impliziten Parameterdefinition stehen.

3 Wenn eine Methode nur einen Parameter hat, der ein impliziter Konvertierungsparameter ist, der implizite Der Schlüssel kann direkt definiert werden. Für wortmodifizierte Parameter können Sie den Typ direkt erstellen, ohne beim Aufruf Parameter zu übergeben.

4. Wenn eine Methode mehrere Parameter hat, muss Currying am Ende verwendet werden und kann nur einmal vorkommen.

package com.bjsxt.scala
 
 
object ImplicitValue {
  /**
   * 隐式值和隐式参数需要注意以下几点：
   * 1.同类型的参数的隐式值只能在作用域内出现一次，同一个作用域内不能定义多个类型一样的隐式值。
   * 2.implicit关键字必须放在隐式参数定义的开头
   * 3.一个方法只有一个参数是隐式转换参数时，那么可以直接定义implicit关键字修饰的参数，调用时直接创建类型不传入参数即可。
   * 4.一个方法如果有多个参数，要实现部分参数的隐式转换，必须使用柯里化这种方式，隐式关键字出现在后面，只能出现一次
   */
 
    //   * 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
  }
}

Nach dem Login kopieren

Das Ausgabeergebnis: Die entsprechende Funktion wird automatisch gefunden und eine implizite Konvertierung durchgeführt.

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

2. Implizite Konvertierungsfunktion

Die implizite Konvertierungsfunktion ist eine mit dem Schlüsselwort implicit modifizierte Methode. Wenn Scala ausgeführt wird, nehmen wir an, dass eine Variable vom Typ A die Methode method() aufruft und festgestellt wird, dass die Variable vom Typ A keine Methode method() hat und die Variable vom Typ B diese Methode() hat Methode sucht nach einer impliziten Konvertierung im Bereich. Die Funktion konvertiert Typ A in Typ B. Wenn es eine implizite Konvertierungsfunktion gibt, kann Typ A method() aufrufen.

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....

3. Implizite Klassen

Die mit dem Schlüsselwort implicit geänderte Klasse ist eine implizite Klasse. Wenn eine Variable A keine bestimmten Methoden oder Variablen hat und diese Variable A bestimmte Methoden oder bestimmte Variablen aufrufen kann, können Sie eine implizite Klasse definieren. Diese Methoden oder Variablen werden in der impliziten Klasse einfach übergeben .

Hinweis zu impliziten Klassen:

1. Implizite Klassen müssen in Klassen, Paketobjekten und Begleitobjekten definiert werden.

2. Implizite Klassen Der Konstruktor darf nur einen Parameter haben und implizite Klassen desselben Konstruktortyps können nicht in derselben Klasse, demselben Paketobjekt oder demselben Begleitobjekt erscheinen.

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()
  }
 
}

Laufergebnis:

RABBIT is Rabbit....

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die implizite Konvertierung in Java Scala. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!