Scala的高级特性
Scala高级特性
- 高阶函数
1.1. 概念
Scala混合了面向对象和函数式的特性，我们通常将可以作为参数传递到方法中的表达式叫做函数。在函数式编程语言中，函数是“头等公民”，把函数最为参数或者是返回值是函数的函数叫高阶函数
高阶函数包含：作为值的函数、匿名函数、闭包、柯里化等等。
1.2. 作为值的函数
可以像任何其他数据类型一样被传递和操作的函数，每当你想要给算法传入具体动作时这个特性就会变得非常有用。
/**
-
作为值的函数
*/
object MyFunction {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr: Array[Int] = Array(1, 2, 3, 4)
//定义一个函数并将函数复制给fun1
val fun1 = (x: Int) => {
x * 2
}
//同过map方法把调用fun1函数
val map: Array[Int] = arr.map(fun1)map.foreach(line => {
println(line)
})
}
}
定义函数时格式：val 变量名 = (输入参数类型和个数) => 函数实现和返回值类型
“=”表示将函数赋给一个变量
“=>”左面表示输入参数名称、类型和个数，右边表示函数的实现和返回值类型
1.3. 匿名函数
在Scala中，你不需要给每一个函数命名，没有将函数赋给变量的函数叫做匿名函数。
object anonFunction {
def main(args: Array[String]): Unit = {
//定义一个数组
val arr: Array[Int] = Array(1, 2, 3, 4)
//map里面的就是匿名函数
val map: Array[Int] = arr.map((x: Int) => {
x * 2
})
map.foreach(line => {
println(line)
})
}
}
由于Scala可以自动推断出参数的类型，所有可以写的跟精简一些
//map里面的就是匿名函数
val map: Array[Int] = arr.map(x => {
x * 2
})
还记得神奇的下划线吗？甚至可以更简
val map: Array[Int] = arr.map(_ * 2)
1.4. 递归函数
/**
* 递归函数
* 5的阶乘
/
def fun2(num :Int) :Int= {
if(num ==1)
num
else
num * fun2(num-1)
}
print(fun2(5))
1.5. 嵌套函数
/*
* 嵌套函数
* 例如：嵌套函数求5的阶乘
/
def fun5(num:Int)={
def fun6(a:Int,b:Int):Int={
if(a == 1){
b
}else{
fun6(a-1,ab)
}
}
fun6(num,1)
}
println(fun5(5))
1.6. 柯里化
1.6.1. 什么是柯里化
柯里化(Currying)指的是把原来接受多个参数的函数变换成接受一个参数的函数过程，并且返回接受余下的参数且返回结果为一个新函数的技术。
1.6.2. 例子
(1) 一个普通的非柯里化的函数定义，实现一个加法函数：
scala> def plainOldSum(x:Int,y:Int)=x+y
plainOldSum: (x: Int, y: Int)Int
scala> plainOldSum(1,2)
res0: Int = 3
(2) 使用“柯里化”技术来定义这个加法函数，原来函数使用一个参数列表，“柯里化”，把函数定义为多个参数列表：
scala> def curriedSum(x:Int)(y:Int)=x+y
curriedSum: (x: Int)(y: Int)Int
scala> curriedSum(1)(2)
res1: Int = 3
当你调用curriedSum (1)(2)时，实际上是依次调用两个普通函数（非柯里化函数），
第一次调用使用一个参数x，返回一个函数类型的值，
第二次使用参数y调用这个函数类型的值。
(3) 使用下面两个分开的定义在模拟curriedSum柯里化函数：
首先定义第一个函数：
scala> def first(x:Int)=(y:Int)=>x+y
first: (x: Int)Int => Int
然后我们使用参数1调用这个函数来生成第二个函数：
scala> val second =first(1)
second: Int => Int =
scala> second(2)
res2: Int = 3
(4) 使用curriedSum 来定义second
scala> val onePlus=curriedSum(1)_
onePlus: Int => Int =
下划线“_” 作为第二参数列表的占位符， 这个定义的返回值为一个函数，当调用时会给调用的参数加一。
scala> onePlus(2)
res3: Int = 3
调用生成的函数，给函数传入参数，即可得到我们想要的结果。
1.6.3. 总结
scala柯里化风格的使用可以简化主函数的复杂度，提高主函数的自闭性，提高功能上的可扩张性、灵活性。可以编写出更加抽象,功能化和高效的函数式代码。
- 隐式转换和隐式参数
2.1. 隐式转换
Scala提供的隐式转换和隐式参数功能，是非常有特色的功能。是Java等编程语言所没有的功能。它可以允许你手动指定，将某种类型的对象转换成其他类型的对象或者是给一个类增加方法。通过这些功能，可以实现非常强大、特殊的功能。其中所有的隐式值和隐式方法必须放到object中。
然而使用Scala的隐式转换是有一定的限制的，总结如下：
implicit关键字只能用来修饰方法、变量（参数)。
隐式转换的方法在当前范围内才有效。如果隐式转换不在当前范围内定义（比如定义在另一个类中或包含在某个对象中），那么必须通过import语句将其导入。
//通过这种方式导入
类名.方法
import Scala01.f1
隐式转换函数名可以是任意的,隐式转换与函数名有关,只与函数参数类型和返回值类型有关
隐式函数可以有多个,就是隐式函数列表,但是必须保证当前环境下,只有一个隐式函数能被识别
object Scala03 {
def main(args: Array[String]): Unit = {
implicit def f1(double: Double): Int ={
double.toInt
}
implicit def f2(double: Double): Int = {
double.toInt
}
implicit def f3(float: Float): Int ={
float.toInt
}
val a:Int=2.34
}
}
隐式装换需要隐式装换的方法
隐式装换的方法使用例如:
implicit def f1(d: Double): Int = {
d.toInt
}
2.2. 对象转换案例一
优雅的解决数据类型转换问题
object Scala01 {
//定义一个隐式转换的方法 实现double–>int
implicit def f1(d: Double): Int = {
d.toInt
}
def main(args: Array[String]): Unit = {
//转换成功
val a: Int = 4.5
val b: Int = 5.6
}
def function01(): Unit ={
val c:Int=1.123123
}
}
2.3. 对象转换案例二
通过隐式转换丰富我们类库的功能
如果为一个动态的增加一个方法,可以通过隐式转换的形式来实现(动态增加功能)
OCP(Open-Closed Principle)原则:对修改关闭,对扩展开发
给Mysql类增加一个delete的方法
package com.bw.myimplicit
/**
-
动态的给Mysql增加delete 方法
*/
object Scala04 {
def main(args: Array[String]): Unit = {
//隐式方法
implicit def addDelete(mysql: Mysql): DB = {
new DB
}//创建msyql
val mysql: Mysql = new Mysql()
mysql.insert()
//增加一个删除的方法
mysql.delete()
}
}
class Mysql {
def insert(): Unit = {
println(“insert into data database”)
}
}
class DB {
def delete(): Unit = {
println(“delete data from database”)
}
}
2.4. 扩展知识
① 隐式转换案例一（让File类具备RichFile类中的read方法）
package cn.itcast.implic_demo
import java.io.File
import scala.io.Source
object MyPredef{
//定义隐式转换方法
implicit def file2RichFile(file: File)=new RichFile(file)
}
class RichFile(val f:File) {
def read()=Source.fromFile(f).mkString
}
object RichFile{
def main(args: Array[String]) {
val f=new File(“E://words.txt”)
//使用import导入隐式转换方法
import MyPredef._
//通过隐式转换，让File类具备了RichFile类中的方法
val content=f.read()
println(content)
}
}
② 隐式转换案例二（超人变身）
package cn.itcast.implic_demo
class Man(val name:String)
class SuperMan(val name: String) {
def heat=print(“超人打怪兽”)
}
object SuperMan{
//隐式转换方法
implicit def man2SuperMan(man:Man)=new SuperMan(man.name)
def main(args: Array[String]) {
val hero=new Man(“hero”)
//Man具备了SuperMan的方法
hero.heat
}
}
③ 隐式转换案例三（一个类隐式转换成具有相同方法的多个类）
package cn.itcast.implic_demo
class A(c:C) {
def readBook(): Unit ={
println(“A说：好书好书…”)
}
}
class B(c:C){
def readBook(): Unit ={
println(“B说：看不懂…”)
}
def writeBook(): Unit ={
println(“B说：不会写…”)
}
}
class C
object AB{
//创建一个类的2个类的隐式转换
implicit def C2A(c:C)=new A©
implicit def C2B(c:C)=new B©
}
object B{
def main(args: Array[String]) {
//导包
//1. import AB._ 会将AB类下的所有隐式转换导进来
//2. import AB._C2A 只导入C类到A类的的隐式转换方法
//3. import AB.C2B 只导入C类到B类的的隐式转换方法
import AB.
val c=new C
//由于A类与B类中都有readBook()，只能导入其中一个，否则调用共同方法时代码报错
//c.readBook()
//C类可以执行B类中的writeBook()
c.writeBook()
}
}
④ 隐式参数案例四（员工领取薪水）
package cn.itcast.implic_demo
object Company{
//在object中定义隐式值 注意：同一类型的隐式值只允许出现一次，否则会报错
implicit val aaa=“zhangsan”
implicit val bbb=10000.00
}
class Boss {
//注意参数匹配的类型 它需要的是String类型的隐式值
def callName()(implicit name:String):String={
name+" is coming !"
}
//定义一个用implicit修饰的参数
//注意参数匹配的类型 它需要的是Double类型的隐式值
def getMoney()(implicit money:Double):String={
" 当月薪水："+money
}
}
object Boss extends App{
//使用import导入定义好的隐式值，注意：必须先加载否则会报错
import Company._
val boss =new Boss
println(boss.callName()+boss.getMoney())
}
- Scala中函数和方法区别
a.方法不能作为单独的表达式而存在，但是函数可以
b.函数必须有参数列表，就算是空的也需要写上，方法可以没有
//1.函数的定义
val sayName = () => {
println("他的名字叫 :" +)
}
def eat: Unit = {
println("在吃东西------------")
}
c.方法不是值，函数是值，不能把方法赋值给变量val
//2.方法的定义（如果强行复制一个变量，就会出现问题）
val bb= def eat(): Unit = {
println("在吃东西------------")
}
d.方法可以转化为函数，函数不可以成方法
val cc=eat _
println(cc.getClass.getName)
- 嵌套函数和递归函数的区别
递归调用 是自己调用自己，函数嵌套可以是调用其他函数