科里化函数
object KeliDemo {
def k(x: Int)(y:Int): Int ={
println("aaa")
x+y
}
def k2(x: Int)(implicit y: Int = 10) = {x+y}
def k3(x: Int = 10)(y: Int) = {x+y}
def main(args: Array[String]): Unit = {
val f = k(5)_ //定义这个函数没有打印方法中的"aaa"
val r = f(8) //调用这个函数打印了方法中的"aaa"
println(r)
val f1 = (a: Int) =>{
k(5)(a)
} //定义这个函数没有打印方法中的"aaa"
val r2 = f1(8) //调用这个函数打印了方法中的"aaa"
println(r2)
val r3: Int = k2(8)
println(r3)
//如果有方法中有implicit修饰的参数,在编译时,会在上下文找类型一致的参数,,如果有就传入
//优先级 手动输入 k2(10)(878) = 888 > 定义参数 { implicit val www =656} >默认值
// implicit val www =656
// val r4 = k2(10) //666
import MyContext.iii
var r5 = k2(11)
println(r5)
//在一个括号中 implicit只能放在第一个参数前;两个括号 implicit只能放在第二个括号中
}
}
简述Int调用to方法的流程
import scala.runtime.RichInt
object ToDemo {
def main(args: Array[String]): Unit = {
//调用to方法,就是最典型的隐式转换,是对类的扩展和增强
//Int中和他的父类中没有 to 方法 , 幕后 将 Int转成了 RichInt,然后可以调用to方法了
//隐式转换本质是两种设计模式:装饰+外观(简化方法的调用)
var r1 = 1 to 10
//装饰(包装),将Int包装成Rich,然后再调用RichInt的to方法
val r2 = new RichInt(1).to(10) //显示的包装
for (elem <- r2) {
println(elem)
}
}
}
代码实现隐式转换
Test实现类
import java.io.File
object FileDemo {
def main(args: Array[String]): Unit = {
val file = new File("/D:/abc.txt")
import MyContext._
val content: String = file.read()
println(content)
}
}
当创建了一个file实例时,file是没有read方法的,所以要先将file包装成FileRich类型
import java.io.File
import scala.io.Source
class RichFile(val file: File) {
def read(): String = {
Source.fromFile(file).mkString
}
}
然后再在implicit的类中定义隐式的方法或函数
import java.io.File
object MyContext {
implicit val iii = 100
//定义一个隐式的方法或函数 (方法和函数都存在的时候优先调用函数) implicit 优先找引用类型 没有引用类型的话可以找方法 因为编译器可以将方法转换成函数
implicit def fileToRichFile(file: File):RichFile = {
println("implicit method invoked")
new RichFile(file)
}
implicit val file2RichFile=(file:File) =>{
println("implicit function invoked")
new RichFile(file)
}
}