Scala的高级特性

Scala高级特性

1. 高阶函数
   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. 隐式转换和隐式参数
   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())

}

3. 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)

4. 嵌套函数和递归函数的区别
   递归调用 是自己调用自己，函数嵌套可以是调用其他函数