Scala泛型、隐式转换和隐式参数、视图介绍、Scala中的上界、下界、结合柯里化进行隐式转换

最新推荐文章于 2022-01-23 20:02:51 发布
最新推荐文章于 2022-01-23 20:02:51 发布
阅读量148 收藏
点赞数
分类专栏： Scala

二、泛型

一、Scala泛型 
1. 泛型介绍 
泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。泛型的典型应用场景是集合及集合中的方法参数，可以说同java一样，scala中泛型无处不在，具体可以查看scala的api。 
2. 泛型类、泛型方法 
泛型类：指定类可以接受任意类型参数。 
泛型方法：指定方法可以接受任意类型参数。 
3. 案例 
案例一：

package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  * 下面的意思就是表示只要是Comparable就可以传递,下面是类上定义的泛型
  */
/*class MrRight[T <:Comparable[T]] {
  //定义一个选择方法，实现选择的功能
  def choose(first : T,second : T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}*/

/**
  * 在类上定义泛型可以，当然，也可以在方法上定义泛型，定义的方式如下：
  */
class MrRight {
  def choose[T <: Comparable[T]](first:T,second:T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}

object MrRight {
  def main(args: Array[String]): Unit = {
//    //如果是类上定义的泛型，通过下面的方式调用
//    val mr = new MrRight[Boy]
//    val b1 = new Boy("laoduan",99)
//    val b2 = new Boy("laozhao",9999)
//    val boy = mr.choose(b1,b2)
//    //结果是：laozhao
//    println(boy.name)

    //如果是在方法上定义的泛型，可以使用下面的方式：
    var mr = new MrRight
    val b1 = new Boy("laoduan",99)
    val b2 = new Boy("laozhao",9999)
    val boy = mr.choose[Boy](b1,b2)
    //结果同样是：laozhao
    println(boy.name)
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41

案例二：

package cn.toto.scala.enhance

/**
  * Created by toto on 2017/7/1.
  * 泛型类，泛型方法
  * 泛型用于指定方法或类可以接受任意类型参数
  * 参数在实际使用时才被确定
  * 泛型可以有效地增强程序的适用性
  * 使用泛型可以使用得类或方法具有更强的通用性
  */
//泛型类    F S T是类型的参数
class GenericClass[F,S,T](val f:F,val s:S,val t:T)
object GenericDemo {

  //泛型方法
  def getData[T](list:List[T]) = list(list.length/2)

  /**
    * 运行结果：
    * 26
    * 3
    */
  def main(args : Array[String]): Unit = {
    //实例化方式1
    val gc1 = new GenericClass("lisha",26,"beijing")
    //实例化方式2
    val gc2 = new GenericClass[String,String,Int]("lisha","beijing",26)

    println(getData(List("lisha",26,"beijing")))

    val t = getData[Int] _
    println(t(List(1,2,3,4,5)))
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

二、 隐式转换和隐式参数

1． 概念 
隐式转换和隐式参数是Scala中两个非常强大的功能，利用隐式转换和隐式参数，你可以提供优雅的类库，对类库的使用者隐匿掉那些枯燥乏味的细节。 
2． 作用 
隐式的对类的方法进行增强，丰富现有类库的功能 
3． 隐式转换函数 
是指那种以implicit关键字声明的带有单个参数的函数。

可以通过：:implicit –v这个命令显示所有做隐式转换的类。 
4． 隐式转换例子

package cn.toto.impli

import java.io.File
import scala.io.Source

/**
  * 这个案例是为了一下读出文件中的内容,目的类似通过下面的read方法直接读取出其中的内容：
  * var file = new File("E:\\wordcount\\input\\1.txt");
    var contents = file.read();
  *
  * Created by toto on 2017/7/1.
  * 隐式的增强File类的方法
  */
class RichFile(val from : File){
  //定义一个read方法，返回
  def read() : String = Source.fromFile(from.getPath).mkString
}

object RichFile {
  //隐式转换方法（将原有的File类型转成了file类型，在用的时候需要导入相应的包）
  implicit def file2RichFile(from : File) = new RichFile(from)
}

object MainApp {
  def main(args: Array[String]): Unit = {
    val file = new File("E:\\wordcount\\input\\a.txt");
    //装饰模式，显示的增强(本来想实现：val contents = file.read()，但是却使用RichFile的方式，所以是显示的增强)
    val rf = new RichFile(file)
    val contents = rf.read();

    //目的是使用File的时候不知不觉的时候直接使用file.read()方法，所以这里就要做隐式转换

    //导入隐式转换，._将它下满的所有的方法都导入进去了。 导包的代码，可以
    import RichFile._
    //这里没有的read()方法的时候，它就到上面的这一行中的找带有implicit的定义方法
    var content = new File("E:\\wordcount\\input\\a.txt").read
    println()

    //import RichFile.file2RichFile
    //println(file2RichFile(new File("E:\\wordcount\\input\\1.txt")).read)
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
package cn.toto.scala

import java.awt.GridLayout

/**
  * Created by ZX on 2015/11/13.
  */
object ImplicitContext{
  //implicit def girl2Ordered(g : Girl) = new Ordered[Girl]{
  //  override def compare(that: Girl): Int = if (g.faceValue > that.faceValue) 1 else -1
  //}

  implicit object OrderingGirl extends Ordering[Girl]{
    override def compare(x: Girl, y: Girl): Int = if (x.faceValue > y.faceValue) 1 else -1
  }
}

class Girl(var name: String, var faceValue: Double){
  override def toString: String = s"name : $name, faveValue : $faceValue"
}

//class MissRight[T <% Ordered[T]](f: T, s: T){
//  def choose() = if(f > s) f else s
//}
//class MissRight[T](f: T, s: T){
//  def choose()(implicit ord: T => Ordered[T]) = if (f > s) f else s
//}

class MissRight[T: Ordering](val f: T, val s: T){
  def choose()(implicit ord: Ordering[T]) = if(ord.gt(f, s)) f else s
}

object MissRight {
  def main(args: Array[String]) {
    import ImplicitContext.OrderingGirl
    val g1 = new Girl("yuihatano", 99)
    val g2 = new Girl("jzmb", 98)
    val mr = new MissRight(g1, g2)
    val result = mr.choose()
    println(result)
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

视图介绍

隐含参数和方法也可以定义隐式转换，称作视图。视图的绑定从另一个角度看就是implicit的转换。主要用在两个场合： 
 当一个T类型的变量t要装换成A类型时 
 当一个类型T的变量t无法拥有A类型的a方法或变量时 
其实视图的绑定是为了更方便的使用隐式装换 
用符号 <% 表示。

Scala中的上界、下界

1．上界、下界介绍 
在指定泛型类型时，有时需要界定泛型类型的范围，而不是接收任意类型。比如，要求某个泛型类型，必须是某个类的子类，这样在程序中就可以放心的调用父类的方法，程序才能正常的使用与运行。此时，就可以使用上下边界Bounds的特性； 
Scala的上下边界特性允许泛型类型是某个类的子类，或者是某个类的父类；

(1) U >: T

这是类型下界的定义，也就是U必须是类型T的父类(或本身，自己也可以认为是自己的父类)。

(2) S <: T

这是类型上界的定义，也就是S必须是类型T的子类（或本身，自己也可以认为是自己的子类)。

下面是视图介绍和上界、下界的示例代码： 
下面定义两个类

package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  */
class Boy(val name : String,var faceVlue : Int) extends Comparable[Boy] {
  override def compareTo(o: Boy): Int = {
    this.faceVlue - o.faceVlue
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  */
class Girl(val name:String,var faceValue:Int) {

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
这里写代码片
  • 1
package cn.toto.gen

import java.awt.GridLayout
import java.io.File

import cn.toto.impli.RichFile

/**
  * Created by ZhaoXing on 2016/8/18.
  */
object MyPreDef {
  //针对viewbound方式的
//  implicit def girl2Ordered(g : Girl) = new Ordered[Girl] {
//    override def compare(that: Girl): Int = {
//      g.faceValue - that.faceValue
//    }
//  }

  //针对Ordering类型的
  implicit object Girl2Ordering extends Ordering[Girl] {
    override def compare(x: Girl, y: Girl): Int = {
      x.faceValue - y.faceValue
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  * 下面的意思就是表示只要是Comparable就可以传递,下面是类上定义的泛型
  */
/*class MrRight[T <:Comparable[T]] {
  //定义一个选择方法，实现选择的功能
  def choose(first : T,second : T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}*/

/**
  * 在类上定义泛型可以，当然，也可以在方法上定义泛型，定义的方式如下：
  */
class MrRight {
  def choose[T <: Comparable[T]](first:T,second:T) : T = {
    if(first.compareTo(second) > 0) first else second
  }
}

object MrRight {
  def main(args: Array[String]): Unit = {
//    //如果是类上定义的泛型，通过下面的方式调用
//    val mr = new MrRight[Boy]
//    val b1 = new Boy("laoduan",99)
//    val b2 = new Boy("laozhao",9999)
//    val boy = mr.choose(b1,b2)
//    //结果是：laozhao
//    println(boy.name)

    //如果是在方法上定义的泛型，可以使用下面的方式：
    var mr = new MrRight
    val b1 = new Boy("laoduan",99)
    val b2 = new Boy("laozhao",9999)
    val boy = mr.choose[Boy](b1,b2)
    //结果同样是：laozhao
    println(boy.name)
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
package cn.toto.gen

/**
  * Created by toto on 2017/7/1.
  */
//viewbound必须存在一个隐式转换方法,视图界定，必须有一个隐式转换的方法
//class MissRight[T <% Ordered[T]] {
//  def choose(first:T,second : T) : T = {
//    //这里的之所以可以用'>',是因为这里的T可以转换成Order的类型
//    if(first > second) first else second
//  }
//}

//如果使用上下文界定，必须存在一个隐式转换的值，特点是使用Ording，但是不需要使用Ordering[T]
class MissRight[T : Ordering] {
  def select(first : T,second : T) : T = {
    //通过使用implicitly转换类型
    val ord = implicitly[Ordering[T]]
    if(ord.gt(first,second)) first else second
  }
}

object MissRight {
  def main(args: Array[String]): Unit = {
    def main(args: Array[String]): Unit = {
      //这里是使用viewbound方式的。
//      import MyPreDef._
//      val mr = new MissRight[Girl]
//      val g1 = new Girl("ab",90)
//      val g2 = new Girl("aaa",999)
//      val g = mr.choose(g1,g2)
//      println(g.name)

      //这里是针对Order类型的
      import MyPreDef._
      val mr = new MissRight[Girl]
      val g1 = new Girl("ab",90)
      val g2 = new Girl("aaa",999)
      val g = mr.select(g1,g2)
      println(g.name)
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

结合柯里化进行隐式转换： 
代码如下：

package cn.com.toto.gen

/**
  * Created by toto on 2017/7/2.
  */
class Girl(val name : String,var faceValue:Int) {

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
package cn.com.toto.gen

import cn.toto.impli.RichFile

/**
  * Created by toto on 2017/7/2.
  */
object MyPreDef {
  implicit object Girl2Ordering extends Ordering[Girl] {
    override def compare(x: Girl, y: Girl): Int = {
      x.faceValue - y.faceValue
    }
  }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
package cn.com.toto.gen

/**
  * Created by toto on 2017/7/2.
  */
class MissR[T] {

  //如果利用柯里化传入一个隐式转换函数，其作用和Viewbound是一样的，都需要一个隐式转换方法或函数
  def choose(f: T, s: T)(implicit ord: T => Ordered[T]) : T = {
    if (f > s) f else s
  }

  //如果利用柯里化传入一个隐式的类型， 其作用和Contextbound是一样的，都需要一个隐式转换的值
  def select(f: T, s: T)(implicit ord: Ordering[T]) : T = {
    if(ord.gt(f, s)) f else s
  }

  def random(f: T, s: T)(implicit ord: Ordering[T]) : T = {
    import Ordered.orderingToOrdered
    if(f > s) f else s
  }
}

object MissR {
  def main(args : Array[String]): Unit = {
    import MyPreDef._
    val mr = new MissR[Girl]
    val g1 = new Girl("aaa", 80)
    val g2 = new Girl("bbb", 90)
    //val g = mr.choose(g1, g2)
    val g = mr.random(g1, g2)
    //运行结果是：bbb
    println(g.name)
  }
}
张博208
关注
专栏目录
大数据学习之路65-scala的泛型与隐式转换
爱米酱的博客
09-07 331
scala的泛型用[] 正常写法：extends Comparable[Boy] [T &lt;: Comparable]    上界  upper bound [T  &gt;: Comparable]   下界   lower bound [T : Comparable]    上下文界定  context bound [T % Comparable]   视图界定   view b...
【大数据Scala系列】Scala隐式转换和隐式参数
weixin_54707168的博客
03-31 152
【大数据Scala系列】Scala隐式转换和隐式参数
scala-协变、逆变、上界、下界
weixin_34280237的博客
11-20 136
为什么80%的码农都做不了架构师？>>> ...
Scala-隐式转换
Markble
08-31 4014
目录 一、隐式函数 二、隐式参数 三、隐式类 四、隐式解析机制 当编译器第一次编译失败的时候，会在当前的环境中查找能让代码编译通过的方法，用于将类型进行转换，实现二次编译 一、隐式函数 1）说明 隐式转换可以在不需改任何代码的情况下，扩展某个类的功能。 2）案例实操 需求：通过隐式转化为Int类型增加方法。 class MyRichInt(val self: Int) { def myMax(i: Int): Int = { ...
Scala隐式转换
PassionZheng的博客
07-09 379
隐式转换可以在不需改任何代码的情况下，扩展某个类的功能 隐式函数 当编译器第一次编译失败的时候，会在当前的环境中查找能让代码编译通过的方法，用于将类型进行转换，实现二次编译。 案例：通过隐式转化为Int类型增加方法。 class MyRichInt(val self: Int) { def myMax(i: Int): Int = { if (self < i) i else self } def myMin(i: Int): Int = {
Scala-21 隐式转换和隐式参数
自度度人 自觉觉他
01-29 201
文章目录隐式转换利用隐式转换丰富现有类库的功能引入隐式转换隐式转换规则 隐式转换 隐式转换函数（ implicit conversion function ）指的是那种以 implicit关键字声明的带有单个参数的函数。这样的函数将被自动应用，将值从一种类型转换为另一种类型 。 例如Fraction类，将整数n转换为Fraction(n,1)，使用implicit def int2Fractio...
scala2.12.15，供大家学习和使用
最新发布
07-06
Scala还提供了强大的类型系统，包括类型推断、类型安全的泛型和隐式转换。类型推断可以让开发者省略一些显式的类型声明，提高代码的可读性。泛型确保了在编译期间就能检测到类型错误，提高了程序的健壮性。隐式转换...
Scala(中文完整版).zip
12-14
Scala支持泛型，允许在类、方法和对象中使用类型参数，增强了代码的重用性和安全性。 **6. 类型系统** Scala具有强大的类型系统，包括类型推断、类型别名、隐式转换和类型参数绑定。类型推断减少了代码的冗余，隐式...
Scala语言规范中文教程
02-18
- **类型推导边界**：`和`>:`用于指定类型参数的上界和下界。 8. **特质与混合继承** - **特质**：Scala的特质类似Java的接口，但可以包含字段和实现方法。 - **混合继承**：一个类可以继承多个类和特质，解决了...
scala入门-10 隐式转换、隐式参数、隐式类
weixin_30484739的博客
01-13 190
到目前为止，隐式转换是scala的重点和难点了，加油~ 我们先创建一个类名称叫Implicit.scala 再看一个隐式参数的例子： 上面的例子中使用了隐式参数，我们也可以明显的指明参数： 下面看一下隐式类： 相当于： 到目前为止，本人已经把所有scala在spark中开发中所涉及的基础知识练习了一遍了，稍后我会把scal...
Scala之隐式转换与泛型
lslslslslss的博客
01-23 548
一、隐式转换 隐式转换可以在不需改任何代码的情况下，扩展某个类的功能。实际的应用场景 是对于老旧的代码添加功能，如果直接修改源代码 很容易出现未知的bug，推荐使用隐式转换，自定义一个新的类 然后把需要添加功能的类隐式转换为新创建的类。 def main(args: Array[String]): Unit = { // 完成隐式转换 需要添加隐式函数 // 将当前作用域的所有int值 隐式转换为MyRichInt类 implicit def chang...
scala_集合_泛型_隐式转换
weixin_33699914的博客
05-22 191
集合listsettuplemap访问数据应该是下划线1，2，如hostPort._1。下标是从1开始的。packagecn.chinahadoop.scala classBasic5{ } //默认为val caseclassBook(name:String,author:String) objectBasic5exten...
scala 隐式转换
大怀特的博客
10-11 2534
文章目录作用解决什么问题使用 implicits 的一些规则3.1.1 标记规则3.1.2 范围规则3.1.3 一次规则3.1.4 优先规则3.1.5 命名规则3.1.6 编译器使用 implicit 的几种情况3.2 隐含类型转换3.3 转换被方法调用的对象3.3.1 支持新的类型3.3.2 模拟新的语法结构实验总结implicit基本含义隐式转换隐式转换的另一个优点是它们支持目标类型转换.隐式转换操作规则隐式参数和spring 的依赖注入之前关系与区别隐式转换类(Implicit Classes)隐式类
scala隐式转换
u012447842的博客
05-25 1205
简述： 1： 通过隐式转换，程序员可以在编写Scala程序时故意漏掉一些信息，让编译器去尝试在编译期间自动推导出这些信息来，这种特性减少代码量，忽略那些冗长的代码。 2： 我们经常引入第三方库，但当我们想要扩展新功能的时候通常是很不方便的，因为我们不能直接修改其代码。scala提供了隐式转换机制和隐式参数帮我们解决诸如这样的问题。 Scala中的隐式转换是一种非常强大的代码查找机制。当函数、构造器调用缺少参数或者某一实例调用了其他类型的方法导致编译不通过时，编译器会尝试搜索一些特定的区域，尝试使编译
Scala中的隐式转换
象在舞的技术专栏
09-03 517
Scala提供的隐式转换和隐式参数功能，是非常有特色的功能。是Java等编程语言所没有的功能。它可以允许你手动指定，将某种类型的对象转换成其他类型的对象。通过这些功能，可以实现非常强大，而且特殊的功能。 Scala的隐式转换，其实最核心的就是定义隐式转换函数，即implicit conversion function。定义的隐式转换函数，只要在编写的程序内引入，就会被Scala自动使用。Scal
Scala隐式函数|隐式参数|隐式类|隐式处理机制
SmallScorpion
04-11 557
隐式函数 当编译器第一次编译失败的时候，会在当前的环境中查找能让代码编译通过的方法，用于将类型进行转换，实现二次编译 隐式转换可以在不需改任何代码的情况下，扩展某个类的功能。 隐式参数 普通方法或者函数中的参数可以通过implicit关键字声明为隐式参数，调用该方法时，就可以传入该参数，编译器会在相应的作用域寻找符合条件的隐式值。 同一个作用域中，相同类型的隐式值只能有一个 编译器按...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值