Chapter12

package scala
import java.awt.event.{ActionEvent, ActionListener}
import javax.swing.JButton

import scala.math._

/**
  * Created by EX-CHENZECHAO001 on 2018-04-04.
  */
class Chapter12 {

}

object Chapter12 {
  // 12.3 带函数参数的函数
  // 这里的参数可以是任何接受Double并返回Double的函数。ValueAtOneQuarter函数将计算那个函数在0.25的位置的值
  def valueAtonQuarter(f: (Double) => Double) = f(0.25)
  valueAtonQuarter(ceil _)  // 1.0
  valueAtonQuarter(sqrt _)  // 0.5(0.5 * 0.5 = 0.25)
  // valueAtonQuarter是一个带有单个参数的函数，它的类型写做 (参数类型) => (结果类型)
  // valueAtonQuarter类型为((Double) => Double) => Double
  // 接受函数参数的函数，称做高阶函数(higher-order funcation)
  // 高阶函数可以产出另外一个函数
  def mulBy(factor: Double) = (x: Double) => factor * x
  val result1203 = mulBy(3)
  result1203(20) // 60
  // mulBy函数有一个类型为Double的参数，返回一个类型为(Double) => Double的函数，因此，它的类型为 (Double) => ((Double) => Double)

  // 12.4 参数(类型)推断
  valueAtonQuarter((x:Double) => 3 * x)
  // 由于valueAtonQuarter方法知道你会传入一个类型为(Double)=Double的函数，可简写为
  valueAtonQuarter((x) => 3 * x)
  // 对于只有一个参数的函数，可省略参数外围的()
  valueAtonQuarter(x => 3 * x)
  // 如果参数在=>只出现一次，可用_替换
  valueAtonQuarter(3 * _)
  // 这些简写仅在参数类型已知的情况下有效

  // 12.5 一些有用的高阶函数
  // 0.1 - 0.9集合
  (1 to 9).map(0.1 * _)
  // 打印三角形
  (1 to 9).map("*" * _).foreach(println _)
  // 得到一个序列中的所有偶数
  (1 to 9).filter(_ % 2 == 0)
  // reduceLeft方法接受一个二元的函数，即一个带有两个参数的函数，并将它应用到序列中的所有元素，从左到右
  (1 to 9).reduceLeft(_ * _) // 等同 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9
  // 按单词长度排序
  "Mary has a little lamb".split(" ").sortWith(_.length <= _.length)

  // 12.6 闭包
  val triple = mulBy(3)
  val half = mulBy(0.5)
  println(triple(14) + " " + half(14)) // 将打印 42 7
  // 闭包由代码和代码乃至的任何非局部变量定义构成

  // 12.7 SAM转换
  // 按钮被点击时递增一个计数器
  var counter = 0
  val button = new JButton("Increment")
  button.addActionListener(new ActionListener {
    override def actionPerformed(e: ActionEvent): Unit = {
      counter += 1
    }
  })

  /*

  button.addActionListener((event: ActionEvent) => countter += 1)

  implicit def makAction(action: (ActionEvent) => Unit) = {
    new ActionListener {
      override def actionPerformed(e: ActionEvent): Unit = {
        action(event)
      }
    }
  }
  //////////////// 未理解
  */

  // 12.8 柯里化
  // 柯里化指的是将原来接受两个参数的函数变成新的接受一个参数的函数的过程。新的函数返回一个以原有第二个参数作为参数的函数
  def mul(x: Int, y: Int) = {
    x * y
  }

  // 以下函数接受一个参数，生成另一个接受单个参数的函数
  def mulOneAtATime(x: Int) = (y: Int) => x * y

  // 计算两个数的乘积，调用命令
  mulOneAtATime(6)(7)
  //  mulOneAtATime(6)的结果是函数(y: Int) => 6 * y，这个函数又这被应用到7，因此最终得到42
  // Scala支持如下简写来定义这样的柯里化函数
  def mulOneAtATime1208(x: Int)(y: Int) = x * y
  // 作用： 通过柯里化把某个函数参数单拎出来，以提供更多用于类型推断的信息

  // 比较两个序列是否在某个对比条件下相同
  val a = Array("Hello", "scala")
  val b = Array("Hello", "java")
  a.corresponds(b)(_.equalsIgnoreCase(_))

  // 12.9 控制抽象
  // 在Scala中，我们可以将一系列的语句组成不带参数也没有返回值的函数
  // 类型() => Unit
  def runInThread(block: () => Unit): Unit ={
    new Thread {
      override def run(): Unit = {
        block()
      }
    }.start()
  }
  runInThread{
    () => println("Hi")
      Thread.sleep(1000)
      println("Bye")
  }
  // 在调用中省掉 () => ，可以使用换名调用表示法：在参数声明和调用该函数参数的地方略去()，但保留=>
  def runInThread(block: => Unit): Unit ={
    new Thread{
      override def run(): Unit = {
        block
      }
    }.start()
  }
  // 调用代码
  runInThread{
    println("Hi")
    Thread.sleep(1000)
    println("Bye")
  }

// 测试
(1 to 9).map(x => {
  runInThread{
    println(x)
    Thread.sleep(x * 1000)
    println("Bye " + x)
  }
})

  //
  def until1209(condition: => Boolean)(block: => Unit): Unit ={
    if(!condition){
      block
      until1209(condition)(block)
    }
  }
  // 调用
  var x = 10
  until1209(x == 0){
    x -= 1
    println(x)
  }
//////////////// 需重新重点理解

  // 12.10 return表达式
  // 在Scala中，不需要用return语句来返回函数值。函数的返回值就是函数体的值
  // 可以用return来从一个匿名函数中返回值给包含这个匿名函数的带名函数。
  def indexOf(str: String, ch: Char): Int = {
    var i = 0
    until1209(i == str.length) {
      if(str(i) == ch)  return i
      i += 1
    }
    return -1
  }

}