scala的隐式转换学习总结(详细)

scala的隐式转换学习总结(详细)scala隐式转换,详细介绍

大家好,又见面了,我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

一,隐式转换函数

     1, 格式,           

implicit def 函数名(参数):返回值类型={
     //函数体
     //返回值
}

     2,例子:

//导入对应的规则类,以免出现警告
scala> import scala.language.implicitConversions
import scala.language.implicitConversions
//定义将Int类型的值转换为Float的函数
scala> implicit def int2float(x:Int): Float = x.toFloat
int2float: (x: Int)Float

scala> val x:Float = 2
x: Float = 2.0
scala>

  3,注意事项:

      1) 隐式转换函数的函数名可以是任意的,与函数名称无关,只与函数签名(函数参数和返回值类型)有关。

      2)如果当前作用域中存在函数签名相同但函数名称不同的两个隐式转换函数,则在进行隐式转换时会报错。

//函数一
scala> implicit def int2float2(x: Float): Int = x.toInt
int2float2: (x: Float)Int
//函数二
scala> implicit def int2float(x: Float): Int = x.toInt
int2float: (x: Float)Int
//调用,报错
scala> val x:Int = 2.55f
<console>:14: error: type mismatch;
 found   : Float(2.55)
 required: Int
Note that implicit conversions are not applicable because they are ambiguous:
 both method int2float2 of type (x: Float)Int
 and method int2float of type (x: Float)Int
 are possible conversion functions from Float(2.55) to Int
       val x:Int = 2.55f
                   ^

 二,隐式类与隐式对象

    1,隐式类:通过在类名前使用 implicit 关键字定义

         1)格式:

implicit class 类名(参数){
    //类主体
}

 例子:string中没有bark方法,通过隐式转换,调用对应的方法转换

scala> implicit class Dog(val name: String){
     | def bark=println(s"$name is barking")}
defined class Dog

scala> "barkdo".bark
barkdo is barking

 2)注意事项: 隐式类的主构造函数参数有且仅有一个!之所以只能有一个参数,是因为隐式转换是将一种类型转换为另外一种类型,源类型与目标类型是一一对应的

scala> implicit class Dog2(val name: String, val age: Int){
     | def bark=println(s"$name is barking")}
<console>:15: error: implicit classes must accept exactly one primary constructor parameter
       implicit class Dog2(val name: String, val age: Int){
  
  

    2  隐式对象

        格式:

implicit object 对象名{
    //类主体
}

      例子

object ImplicitTest extends App{
   //定义一个trait Multiplicable
  trait Multiplicable[T]{
     def multiply(x: T):T
   }
  //定义一个隐式对象,用于整型数据相乘
  implicit object MultiplicableInt extends Multiplicable[Int]{
    def multiply(x: Int): Int = x*x
  }
  //定义一个用于字符串相乘的隐式对象
  implicit object MultiplicableString extends Multiplicable[String]{
    def multiply(x: String): String = x*2
  }
  //定义一个函数,函数具有泛型参数
  def multiply[T: Multiplicable](x: T): T ={
    //implicitly方法,访问隐式对象
    val ev = implicitly[Multiplicable[T]]
    //根据具体的类型调用相应的隐式对象中的方法
    ev.multiply(x)
  }

  //调用隐式对象 MultiplicableInt 中的方法
  println(multiply(5))

  //调用隐式对象 MultiplicableString 中的方法
  println(multiply("5"))
}

 运行结果:

25
55

三,隐式参数与隐式值

   1, 隐式参数,在函数的定义时,在参数前添加implicit关键字。

      格式:

def 函数名(implicit 参数名:l类型):返回值={
       //函数体
}

  例子://修改上面的一个方法

 //定义一个函数,函数具有泛型参数
  def multiply[T: Multiplicable](x: T)(implicit ev: Multiplicable[T]): T ={
    //根据具体的类型调用相应的隐式对象中的方法
    ev.multiply(x)
  }

 2)隐式值:

      格式

implicit val 变量名:类型=值

    例子

//定义一个带隐式参数的函数
scala> def sqrt(implicit x: Double) = Math.sqrt(x)
sqrt: (implicit x: Double)Double
//定义一个隐式值
scala> implicit val x:Double = 2.55
x: Double = 2.55
//调用定义的sqrt函数,它将自行调用定义好的隐式值
scala> sqrt
res1: Double = 1.5968719422671311

    3,隐式参数使用的常见问题:

      1)当函数没有柯里化时,implicit关键字会作用于函数列表中的的所有参数。

      2)隐式参数使用时要么全部不指定,要么全不指定,不能只指定部分。
      3)同类型的隐式值只能在作用域内出现一次,即不能在同一个作用域中定义多个相同类型的隐式值。

      4)在指定隐式参数时,implicit 关键字只能出现在参数开头。

      5)如果想要实现参数的部分隐式参数,只能使用函数的柯里化,

          如要实现这种形式的函数,def test(x:Int, implicit  y: Double)的形式,必须使用柯里化实现:def test(x: Int)(implicit y: Double).

       6) 柯里化的函数, implicit 关键字只能作用于最后一个参数。否则,不合法。

       7)implicit 关键字在隐式参数中只能出现一次,柯里化的函数也不例外!

scala> def product(implicit x: Double, implicit y: Double)=x*y
<console>:1: error: identifier expected but 'implicit' found.
def product(implicit x: Double, implicit y: Double)=x*y
scala> def product(implicit x: Double)(implicit y: Double)=x*y  //柯里化函数
<console>:1: error: '=' expected but '(' found.
def product(implicit x: Double)(implicit y: Double)=x*y

   8)匿名函数不能使用隐式参数

scala> val prodeuct = (x: Double, y: Double) => x*y
prodeuct: (Double, Double) => Double = <function2>

scala> val prodeuct = (implicit x: Double, y: Double) => x*y
<console>:1: error: '=>' expected but ',' found.
val prodeuct = (implicit x: Double, y: Double) => x*y
                                  ^

  9)柯里化的函数如果有隐式参数,则不能使用其偏应用函数

  

//柯里化函数product
scala> def product(x: Double)(y: Double)=x*y
product: (x: Double)(y: Double)Double
//两个参数的偏应用函数
scala> val p1=product _
p1: Double => (Double => Double) = <function1>
//调用
scala> p1(3.0)(4.0)
res1: Double = 12.0
//一个参数的偏应用函数
scala> val p2 = product(3.0) _
p2: Double => Double = <function1>
//调用
scala> p2(4.0)
res2: Double = 12.0
//将柯里化函数参数y, 声明为隐式参数
scala> def product(x: Double)(implicit y: Double)=x*y
product: (x: Double)(implicit y: Double)Double
//定义隐式参数后,便不能使用其偏应用函数
scala> val p1=product _
<console>:13: error: could not find implicit value for parameter y: Double
       val p1=product _
              ^
scala>

四,隐式函数的若干规则:

      1)显示定义规则

             在使用带有隐式参数的函数时,如果没有明确指定与参数类型匹配相同的隐式值,编译器不会通过额外的隐式转换来确定函数的要求。

      2)作用域规则

            不管是隐式值,隐式对象,隐式类或隐式转换函数,都必须在当前的作用域使用才能起作用!

      3)无歧义规则

             所谓无歧义值的是,不能存在多个隐式转换是代码合法,如代码中不应该存在两个隐式转换函数能够同时使某一类型转换为另一类型,也不应该存在相同的两个隐式值,主构造函数参数类型以及成员方法等同的两个隐式类。

     4)一次性转换规则

             隐式转换从源类型到目标类型只会经过一次转换,不会经过多次隐式转换达到。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/183287.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

  • Perl 正则表达式替换

    Perl 正则表达式替换文本处理中经常需要将字符串中的某些字符替换后再进行处理,以下是新发现的非常方便的方法,充分发挥了Perl正则表达式的威力。$str=”thisisatesting”;$str=~s/(/w+)(/w+)/$2$1/;print$str;————————————OUTPUT:isthisatesti

  • docker 常用命令大全

    docker 常用命令大全Docker常用命令大全

  • linux服务器,卸载tensorflow CPU 安装PGU版

    linux服务器,卸载tensorflow CPU 安装PGU版linux服务器,卸载tensorflowCPU安装PGU版写在前面之前用的和学习的都是pytorch框架,现在要运行一个keras的代码,得安装tensorflow和keras,按一个教程,直接在pycharm里setting,点那个+很快就装好了tensorflow和keras,运行了几次发现运行特别慢,用nvidia-smi查看,发现根本没有用pgu跑,一番查找,最后发现安装的tensorflow本身是按CPU跑的,要用GPU跑,得安装tensorflow-gpu。以下主要参考了https

  • Perl正则表达式 模式匹配[通俗易懂]

    Perl正则表达式 模式匹配[通俗易懂]m运算符与匹配修饰符含义i关闭大小写敏感性m将字符串作为多行处理o只编译模式一次。用于优化搜索流程s嵌入换行符时,将字符串作为单行处理x允许在正则表达式中提供注释,并忽略空白字符g全局匹配,即查找所有具体值。如果用于数组型上下文语境,则会返回一个列表;如果用于标量型上下文语境,则返回真或假s运算符与替换格式:s/ol

  • mysql 添加索引卡死_mysql添加索引,查询反而变慢

    mysql 添加索引卡死_mysql添加索引,查询反而变慢依照楼主的数据,我也造了400万数据:mysql>select*fromindex_testlimit5;id1id211111111112222222222111111111122222222221111111111id1创建索引执行确实是id2谓词条件比较快:mysql>select*fromindex_testwhereid1=11111;2097152…

  • 多图详解 DeepMind 的超人类水准星际争霸 AI 「AlphaStar」 …

    多图详解 DeepMind 的超人类水准星际争霸 AI 「AlphaStar」 …雷锋网(公众号:雷锋网)AI科技评论按:英国当地时间1月24日,DeepMind在伦敦组织线上直播,向全世界的游戏AI研究人员以及游戏爱好者们介绍自己的AI研发最新进展。参加直播的DeepMind研究人员是DeepMind团队联合研发负责人OriolVinyals和DavidSilver,后者也是Alph…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号