大数据面试-Scala

谈谈scala的闭包、柯里化、高阶函数

如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包。
闭包在函数式编程中是一个重要的概念，广泛用于高阶函数、柯里化等技术中。

函数柯里化：把一个参数列表的多个参数，变成多个参数列表；
函数柯里化，其实就是将复杂的参数逻辑变得简单化,函数柯里化一定存在闭包。

高阶函数：1）函数可以作为值进行传递
2）函数可以作为参数进行传递
3）函数可以作为函数返回值返回

package com.scala.Function
object test_bibao {
  def main(args: Array[String]): Unit = {
    //普通函数
    def makeMultiplier(factor:Int):Int={
      return factor+1
    }
    println(makeMultiplier(1))

    //闭包函数：如果一个函数，访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境，称为闭包
    def makeMultiplier1(factor: Int): Int=>Int = {
      // 定义一个闭包函数
      //val multiplier = (x: Int) => x * factor  //匿名函数
      def multiplier(x:Int):Int={
        x * factor
      }
      // 返回闭包函数
      multiplier
       }
    println(makeMultiplier1(1)(1))

    //闭包函数 + 匿名函数
    def makeMultiplier2(factor: Int): Int => Int = {
      // 定义一个闭包匿名函数
      // val multiplier2=(x:Int)=>{x*factor}
      val multiplier2 =(x:Int)=>x*factor
      // 返回闭包函数
      multiplier2
    }
    println(makeMultiplier2(1)(1))


    //函数柯里化（柯里化一定会产生闭包）
    def makeMultiplier3(factor: Int)(x: Int) = {
      x * factor
    }
    println(makeMultiplier3(1)(2))
  }

}

你对scala的伴生对象了解吗？

伴生对象，与类名字相同，可以访问类的私有属性和方法
在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。
Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。
当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员。

/*单例对象实例*/
import java.io._

class Point(val xc: Int, val yc: Int) {
   var x: Int = xc
   var y: Int = yc
   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
   }
}

object Test {
   def main(args: Array[String]) {
      val point = new Point(10, 20)
      printPoint

      def printPoint{
         println ("x 的坐标点 : " + point.x);
         println ("y 的坐标点 : " + point.y);
      }
   }
}

/*伴生对象实例*/
// 私有构造方法
class Marker private(val color:String) {

  println("创建" + this)
 
  override def toString(): String = "颜色标记："+ color
 
}

// 伴生对象，与类名字相同，可以访问类的私有属性和方法
object Marker{
 
    private val markers: Map[String, Marker] = Map(
      "red" -> new Marker("red"),
      "blue" -> new Marker("blue"),
      "green" -> new Marker("green")
    )
   
    def apply(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
 
   
    def getMarker(color:String) = {
      if(markers.contains(color)) markers(color) else null
    }
    def main(args: Array[String]) {
        println(Marker("red"))  
        // 单例函数调用，省略了.(点)符号  
                println(Marker getMarker "blue")  
    }
}