Scala implicit

最新推荐文章于 2021-08-03 14:34:43 发布
最新推荐文章于 2021-08-03 14:34:43 发布
阅读量453 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ym01213/article/details/81108589
版权

Scala提供了Java所不具有的隐式转换和隐式参数功能，可以允许你手动指定，将某种类型的对象转换为其他类型的对象。在Spark中有大量的隐式转换和隐式参数。
Scala的隐式转换， 核心是定义隐式转换函数。 定义的隐式转换函数， 只要在编写的程序内引入， 就会被Scala自动使用。
Scala会根据隐式转换函数的签名， 在程序中使用到隐式转换函数接收的参数类型定义的对象时， 会自动将其传入隐式转换函数， 转换为另外一种类型的对象并返回。这就是“隐式转换” 。
隐式转换函数命名随意， 因为通常不会由用户手动调用， 而是由Scala进行调用。 但是如果要使用隐式转换， 则需要对隐式转换函数进行导入。 因此通常建议将隐式转换函数的名称命名为“one2one” 的形式。

隐式转换：
 * 是scala中的一种特殊功能，它能将一种数据类型A转换成另外一种数据类型B，然后数据类型A就可以拥有数据类型B的所有方法，可以看成是对类的一种增强
 * 隐式转换分为两种:
 * 1,隐式转换函数
 * 2,隐式转换值
 * 定义隐式转换的关键字：implicit
 * 隐式转换的命名方式是：one2one


class SpecialPerson(var name: String)
class Older(var name: String)
class Teacher(var name: String)
class Student(var name: String)

object ImplicitDemo01 {
  def buySpecialTic(p: SpecialPerson) = {
    if (p != null) println(p.name + "-购买了一张特殊票") else println("请购买常人票")
  }
  //定义隐式转换函数，将老人、老师转换为特殊人群类
  implicit def any2SpecialPerson(any:Any):SpecialPerson = {
    if(any.isInstanceOf[Older]) {
      val older = any.asInstanceOf[Older]
      new SpecialPerson(older.name)
    }else if (any.isInstanceOf[Teacher]) {
      val teacher = any.asInstanceOf[Teacher]
      new SpecialPerson(teacher.name)
    }else {
      null
    }
  }

  def main(args: Array[String]): Unit = {
    val older = new Older("老人")
    val tc = new Teacher("老师")
    val stu = new Student("学生")
    
    buySpecialTic(older)
    buySpecialTic(tc)
    buySpecialTic(stu)
  }
}

实质是对类的增强！

class RichFile(var file: File) {
  def read() = {
    val context = Source.fromFile(file).mkString
    println(context)
  }
}

object ImplicitDemo02 {
  def main(args: Array[String]): Unit = {
    //将File类转换成RichFile类，以便可以调用RichFile类中的方法，实际上是对File类的增强
    implicit def file2RichFile(file: File): RichFile = new RichFile(file)

    val f1 = new File("C:\\Users\\root\\Desktop\\hello.txt")
    f1.read
  }
}

隐式参数：
   * 在方法中，被implicit修饰的参数，称为隐式参数
   * 隐式参数分为两种：
   * 1，隐式转换函数
   * 2，隐式转换值

class SingPen {
  def write(context: String) = println(context)
}

object ImplicitDemo03 {

  //pen 作为方法的参数，被implicit修饰，成为隐式参数。在调用方法时，该隐式参数可以自动引用。
  def singForExam(name: String)(implicit pen: SingPen) = {
    pen.write(name)
  }

  def main(args: Array[String]): Unit = {
    //声明隐式转换值
    implicit val singPen = new SingPen

    //每个人签到是都要调用singPen,scala会自动调用
    singForExam("张三")
    singForExam("李四")
    singForExam("王五")
  }
}

隐式转换实现二次 排序-ordered & ordering

对象之间进行大小比较，或者排序，需要具备比较大小的功能
具备比较大小的功能有两种方法：
1，继承：继承Comparable接口，实现comparaTo方法，但是这种方法有一定的局限性，这种局限性就是将比较规则写死，后续进行调整，会影响之前的比较
2，隐式转换
可以很好的解决继承带来的局限性，比较规则不写在类中，而是以隐式转换的形式存在

trait Ordered[A] extends Any with java.lang.Comparable[A]  中有用于比较大小的抽象方法   def compare(that: A): Int

trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable 中有用于比较大小的抽象方法  def compare(x: T, y: T): Int

//方法一：继承
class Girl(var name: String, var age: Int, var faceValue: Int) extends Comparable[Girl] {
  override def compareTo(that: Girl): Int = {
    if (this.age - that.age != 0) this.age - that.age
    else if (this.faceValue - that.faceValue != 0) {
      this.faceValue - that.faceValue
    } else this.name.compareTo(that.name)
  }

  override def toString = s"Girl(name=$name,age = $age,faceValue = $faceValue)"
}

//方法二：隐式转换，将比较器放在类外
class Boy(var name: String, var age: Int, var faceValue: Int) {
  override def toString = s"Boy(name=$name,age = $age,faceValue = $faceValue)"
}

//比较器
class Compare[T] {
  //比较方法，第二个参数是隐式转换函数，目的是将T类型转换为Ordered类型，以便可以使用大小比较的方法
  def compareTo(b1: T, b2: T)(implicit x: T => Ordered[T]): T = {
    if (b1 >= b2) b1 else b2
  }
  //比较方法，第二个参数是隐式转换值，目的是将T类型转换为Ordering类型，以便可以使用大小比较的方法
  def compareTo2(b1: T, b2: T)(implicit ord2: Ordering[T]): T = {
    if (ord2.gteq(b1, b2)) b1 else b2
  }

}

object ImplicitDemo04 {
  def main(args: Array[String]): Unit = {
    //隐式转换函数
    implicit def boy2Ordered(b: Boy): Ordered[Boy] = new Ordered[Boy] {
      override def compare(that: Boy): Int = {
        if (b.age - that.age != 0) b.age - that.age
        else if (b.faceValue - that.faceValue != 0) {
          b.faceValue - that.faceValue
        } else b.name.compareTo(that.name)
      }
    }
    val b1 = new Boy("小明", 18, 90)
    val b2 = new Boy("小王", 16, 95)
    val cp1 = new Compare[Boy]
    val resp = cp1.compareTo(b1, b2)
    println(resp)
    
    //隐式转换值
    implicit val ord2: Ordering[Boy] = new Ordering[Boy] {
      def compare(a: Boy, b: Boy): Int = {
        if (a.age - b.age != 0) a.age - b.age
        else if (a.faceValue - b.faceValue != 0) {
          a.faceValue - b.faceValue
        } else a.name.compareTo(b.name)
      }
    }

    val b4 = new Boy("小明", 18, 90)
    val b5 = new Boy("小王", 16, 95)
    val c3 = new Compare[Boy]
    val resB = c3.compareTo2(b4, b5)
    println(resB)

  }
}

扩大隐式转换的作用域

 * 我们可以将隐式转换函数或隐式转换值定义在一个object对象中，来扩大隐式转换的作用域。
 * 以后在其他地方使用的时候，直接import对应的隐式转换函数或隐式转换值
 * 【注意】隐式转换函数或值只能定义在object对象中

object MyPredef {
  implicit def any2SpecialPerson(any: Any): SpecialPerson = {
    if (any.isInstanceOf[Older]) {
      val older = any.asInstanceOf[Older]
      new SpecialPerson(older.name)
    } else if (any.isInstanceOf[Teacher]) {
      val teacher = any.asInstanceOf[Teacher]
      new SpecialPerson(teacher.name)
    } else {
      null
    }
  }

  implicit def file2RichFile(file: File): RichFile = new RichFile(file)

  implicit val singPen = new SingPen

  implicit def boy2Ordered(b: Boy): Ordered[Boy] = new Ordered[Boy] {
    override def compare(that: Boy): Int = {
      if (b.age - that.age != 0) b.age - that.age
      else if (b.faceValue - that.faceValue != 0) {
        b.faceValue - that.faceValue
      } else b.name.compareTo(that.name)
    }
  }

  implicit val ord2: Ordering[Boy] = new Ordering[Boy] {
    def compare(a: Boy, b: Boy): Int = {
      if (a.age - b.age != 0) a.age - b.age
      else if (a.faceValue - b.faceValue != 0) {
        a.faceValue - b.faceValue
      } else a.name.compareTo(b.name)
    }
  }
}

使用时，直接import即可。

import MyPredef.any2SpecialPerson  //直接导入隐式转换函数

class SpecialPerson(var name: String)
class Older(var name: String)
class Teacher(var name: String)
class Student(var name: String)

object ImplicitDemo01 {
  def buySpecialTic(p: SpecialPerson) = {
    if (p != null) println(p.name + "-购买了一张特殊票") else println("请购买常人票")
  }

  def main(args: Array[String]): Unit = {
    val older = new Older("老人")
    val tc = new Teacher("老师")
    val stu = new Student("学生")
    
    buySpecialTic(older)
    buySpecialTic(tc)
    buySpecialTic(stu)
  }
}
import MyPredef.file2RichFile//直接导入对应的隐式转换值

class RichFile(var file: File) {
  def read() = {
    val context = Source.fromFile(file).mkString
    println(context)
  }
}

object ImplicitDemo02 {
  def main(args: Array[String]): Unit = {
    val f1 = new File("C:\\Users\\root\\Desktop\\hello.txt")
    f1.read
  }
}
import MyPredef.singPen //直接导入隐式转换值

class SingPen {
  def write(context: String) = println(context)
}

object ImplicitDemo03 {
  def singForExam(name: String)(implicit pen: SingPen) = {
    pen.write(name)
  }

  def main(args: Array[String]): Unit = {
    //scala会自动调用
    singForExam("张三")
    singForExam("李四")
    singForExam("王五")
  }
}
import MyPredef.ord2
import MyPredef.boy2Ordered

//方法一：继承
class Girl(var name: String, var age: Int, var faceValue: Int) extends Comparable[Girl] {
  override def compareTo(that: Girl): Int = {
    if (this.age - that.age != 0) this.age - that.age
    else if (this.faceValue - that.faceValue != 0) {
      this.faceValue - that.faceValue
    } else this.name.compareTo(that.name)
  }

  override def toString = s"Girl(name=$name,age = $age,faceValue = $faceValue)"
}

//方法二：隐式转换，将比较器放在类外
class Boy(var name: String, var age: Int, var faceValue: Int) {
  override def toString = s"Boy(name=$name,age = $age,faceValue = $faceValue)"
}

//比较器
class Compare[T] {
  //比较方法，第二个参数是隐式转换函数，目的是将T类型转换为Ordered类型，以便可以使用大小比较的方法
  def compareTo(b1: T, b2: T)(implicit x: T => Ordered[T]): T = {
    if (b1 >= b2) b1 else b2
  }
  //比较方法，第二个参数是隐式转换值，目的是将T类型转换为Ordering类型，以便可以使用大小比较的方法
  def compareTo2(b1: T, b2: T)(implicit ord2: Ordering[T]): T = {
    if (ord2.gteq(b1, b2)) b1 else b2
  }

}

object ImplicitDemo04 {
  def main(args: Array[String]): Unit = {

    val b1 = new Boy("小明", 18, 90)
    val b2 = new Boy("小王", 16, 95)
    val cp1 = new Compare[Boy]
    val resp = cp1.compareTo(b1, b2)
    println(resp)

    val b4 = new Boy("小明", 18, 90)
    val b5 = new Boy("小王", 16, 95)
    val c3 = new Compare[Boy]
    val resB = c3.compareTo2(b4, b5)
    println(resB)

  }
}

视图界定

如：T <% Person
T 只能是Person类及其子类，或者T能隐式转换成Person类

class Person05(var name: String) {
  def sayHello = println(s"hello,i am $name")

  def mkFriends(p: Person05) = {
    sayHello
    p.sayHello
  }
}
class Student05(name: String) extends Person05(name)

class Cat(var name: String) {
  def say = println("喵喵喵...")
}
//视图界定：T <% Person,T 只能是Person类及其子类，或者T能隐式转换成Person类
class Party[T <% Person05](p1: T, p2: T) {
  p1.mkFriends(p2)
}

object ImplicitDemo05 {
  def main(args: Array[String]): Unit = {
    //Person05对象
    val p1 = new Person05("张三")
    val p2 = new Person05("李四")
    val pt = new Party[Person05](p1, p2)
    //Student05对象
    val s1 = new Student05("张三")
    val s2 = new Student05("李四")
    val pt2 = new Party[Student05](s1, s2)

    implicit def cat2Person05(c: Cat): Person05 = new Person05(c.name)
    //Cat对象
    val c1 = new Cat("张三")
    val c2 = new Cat("李四")
    val pt3 = new Party[Cat](c1, c2)
  }
}

 

Devin01213
关注
专栏目录
scala implicit class使用
08-15 2087
官方文档：http://docs.scala-lang.org/zh-cn/overviews/core/implicit-classes.html 介绍 Scala 2.10引入了一种叫做隐式类的新特性。隐式类指的是用implicit关键字修饰的类。在对应的作用域内，带有这个关键字的类的主构造函数可用于隐式转换。 隐式类型是在SIP-13中提出的。 用法 创建隐式类时，
Scala Implicit Conversions (隐式转换)
言の叶の庭
03-20 1259
隐式转换是Scala的强大特性之一，使Scala语法更加灵活，在构建类库时是一个强大的工具。
scala中的implicit
civil的专栏
03-27 8937
前言 scala在2.10版本中引入了implicit关键字，包括两个方面的内容：隐式参数和隐式转换。 隐式参数：把一些变量声明为隐式参数，把一些方法的参数声明为可以支持隐式参数的，当调用方法时，如果没有传递该参数，那么可以去使用隐式参数。 隐式转换：首先提供一些类型转换的能力(通过隐式类和隐式方法)，然后在调用某些方法时，当某些对象的类型不匹配，可以使用对应的隐式转换去转换对象的类型。 impl...
scala隐式参数(implicit)
criss
02-17 314
    SBinary 和 Scalacheck的一部分库，广泛使用了隐式参数。让人联想起了Haskell(一种函数式编程语言)的编程风格，我真心的希望在Scala中这种编程风格更加广泛。这是一种非常有用的技术。 作为开始如下多重入参（柯里化）的例子： scala -&gt; def foo(x: Int)(y: Int) = x+y foo: (x: Int)(y: Int) I...
Scala Implicit 详解
Trigl的博客
02-07 7849
Implicit 是 Scala 中一个很重要的特性，开始学习 Scala 之前一直以为它和 Java 差不多，然而真的看一些 Scala 的源码时却发现并没有想象中那么简单，所以准备写几篇文章来详解 Scala 中异于 Java 的特性，就从 Implicit 开始吧。 在我看来，Implicit 做的事情也是 Scala 主要做的事情，那就是代码压缩，减少模块代码，talk is chea
scala 隐式转换与隐式参数的使用方法
08-25
Scala 隐式转换与隐式参数的使用方法 Scala 中的隐式转换与隐式参数是两个非常重要的概念，它们可以帮助开发者编写更加简洁、灵活和可维护的代码。本文将详细介绍 Scala 中隐式转换与隐式参数的使用方法，并通过...
scala implicit关键字详解(隐式转换函数、隐式类、隐式参数、隐式值)
_明灭的专栏
09-20 4326
scala 隐式(implicit关键字)详解一、Overviewimplicit是scala中的一个关键字，关于它有着丰富的用法，使得scala更灵活和容易扩展。截止目前，scala已经来到了2.12.3版本，本篇文章把目前scala支持的implicit用法作了较为全面的整理，以方便在阅读scala源码的时候稍作参考。文中全部的代码和测试结果均以scala2.12.3为准。闲话不多讲，目前可以见
Scala篇—implicit隐式入门
qq_33451695的博客
08-03 837
Scala篇—implicit隐式入门一、implicit概述1、简介2、为什么需要implicit3、隐式转换机制4、隐式转换规则5、使用implicit须知二、Demo示例1、隐式方法2、隐式类3、隐式参数4、隐式对象 一、implicit概述 1、简介 scala在2.10版本中引入了implicit关键字，包括两个方面的内容：隐式参数和隐式转换。 隐式参数： 把一些变量声明为隐式参数，把一些方法的参数声明为可以支持隐式参数的，当调用方法时，如果没有传递该参数，那么可以去使用隐式参数。 隐式转
scala 隐式详解(implicit关键字)
热门推荐
专注大规模数据处理
08-27 2万+
掌握implicit的用法是阅读spark源码的基础，也是学习scala其它的开源框架的关键，implicit 可分为： 隐式参数 隐式转换类型 隐式调用函数 1.隐式参数当我们在定义方法时，可以把最后一个参数列表标记为implicit，表示该组参数是隐式参数。一个方法只会有一个隐式参数列表，置于方法的最后一个参数列表。如果方法有多个隐式参数，只需一个implicit修饰即可。 当调用包含隐式参数的
Scala 隐式（implicit）详解
自渡
10-07 1242
阅读目录 目录 阅读目录 文章正文 1、Spark 中的隐式思考 2、Scala 隐式使用方式 2.1隐式值 2.2 隐式视图 2.3 隐式类 3、Scala 隐私注意事项 3.1 转换时机 3.2 解析机制 3.3 转换前提 文章参考 文章正文 通过隐式转换，程序员可以在编写Scala程序时故意漏掉一些信息，让编译器去尝试在编译期间自动推导出这些信息来，这种特性可以极大的减少代码量，忽略那些冗长，过于细节的代码。 1、Spark 中的隐式思考 隐式转换是Sc...
scala implicit class
Eric ' s Code Blocks
03-18 1358
scala 是一门 scalable 的语言，扩展性很强。  implicit 是 scala 的一个关键词，当它被用于 class 时，该类将被认为是implicit class，它可以用来扩展现有类的行为和方法 以下在scala REPL中展示implicit class的作用 scala> "HAL".increment :8: error: value increment i
scala的 implicit class
weixin_34406061的博客
10-24 352
2019独角兽企业重金招聘Python工程师标准>>> ...
scala - implicit
lzf的博客
02-14 566
概述 在scala中的implicit意味着可以将一种数据类型自动转换为另一种数据类型，或者在方法调用时某些参数可以自动传递给方法。 隐式类型转换（implicit conversion） 隐式类型转换简单的说，如果在类C的对象o上调用方法m，并且该类不支持方法m，那么Scala将寻找从C到支持m的隐式转换。 String类型的隐式转换 scala.Predef定义了String类型的2...
Scala implicit 隐式详解
shine
05-14 534
implicit的作用，有2点:        第一个扩展其他类，增加方法；class A (val data:Int){ ... } 此时我们希望扩展该类的功能，增加类A的数据显示功能implicit class B(a:A) { def show { println(a.data) } } 此时我们扩展了类A功能，可以如下使用。val...
Scala隐式（ implicit）编程彻底实战之编程进阶（7）
吾心光明
08-16 5341
一：隐式详解1：概念： 隐式（implicit）是Scala的一个强大特性，同时也是一个可能存在正义的特性。使用隐式能够减少代码，能够向已有类型中注入新的方法，也能够创建领域特定语言（DSL）。 隐式之所以产生争议，是因为除了通过Predef对象自动加载的哪些隐式对象外，其他在源码中出现的隐式对象均不是本地对象。隐式对象一旦进入作用域，编译器便能执行该隐式对象以生成方法参数或
深入理解Scala编程：权威指南
本书的 "In Depth" 系列意味着作者将深入剖析 Scala 的各个方面，包括其基础概念如类（Classes）、对象（Objects）、trait、lambda 表达式，以及高级特性如模式匹配、隐式参数（Implicit Parameters）和可选参数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值