Scala入门------Scala函数操作

Scala函数
    1.函数传名调用
        Scala的解析器在解析函数参数（Function arguments）时有俩种方式：
            a.传值调用（call-by-value）：先计算参数表达式的值，再应用到内部函数；
            b.传名调用（call-by-name）：将未计算的参数表达式直接应用到函数内部
            在函数的变量名和变量类型使用 => 符号来设置传名调用
    
    2.指定函数参数名
        调用带有参数的函数时，可以不一定要按照函数设置参数顺序来传参，可以根据函数的参数名来乱顺序传参

    3.函数-可变参数
        Scala通过在参数的类型之后放一个 * 号来设置可变参数（参数类型不变，参数个数可变，可传重复值）

    4.递归函数
        Scala也可以自己写递归函数

    5.默认参数值
        定义函数时在定义参数上可设置默认值

    6.高阶函数
        高阶函数就是操作其他函数的函数，Scala中允许使用高阶函数，高阶函数可以使用其他函数作为参数，或者用函数作为输出结果

    7.内嵌函数
        函数里面定义函数

    8.匿名函数
        列如 var a = def(i:Int , b:Int): Int = a+b就是一个匿名函数

    9.偏应用函数
        看列子：
            def log(date: lang.uitl.Date,message:String): String = {data+"---"+message} //定义一个函数
            def main(agrs: Array[String]){
                Date date = new Date();
                var a = log(date, _:String);
                println(a("message1"));
                println(a("message2"));
                println(a("message3"));
            }
            上面例子中 var a = log(date , _: String)就是偏应用函数    _: 就是偏应用函数的代表
                
    10.函数柯里化（Funciton Currying）
        看例子：
            def sum(a: Int , b: Int): Int=a+b //一个十分普通的Scala函数
            def sum(a:Int)(b:Int): Int = a+b  //被柯里化的函数

以下便是Scala函数的一些代码

package com.uitl

import java.util.Date


object MyFunction {
  //1.函数传名调用
  def time1(): Long = {
    println("获取时间，单位为纳秒");
    System.nanoTime();
  }

  //用来与time3做比较
  def time2(i: Long): Long = {
    println("在time2()")
    println("参数" + i)
    i
  }

  //用来与time2做比较
  def time3(i: => Long): Unit = {
    println("在time3()")
    println("参数" + i)
    i
  }

  //指定函数参数名
  def sum(a: Int, b: Int): Int = {
    a + b
  }

  //可变参数
  def example1(string: String*): Unit = {
    println(string)
  }

  //递归
  def example2(i: Int): Int = {
    if (i <= 0)
      1
    else
      i + example2(i - 1)
  }

  //默认参数值
  def example3(i: Int = 500): Int = i

  //高阶函数 这里的A相当于Java中的泛型 也可以指定类型 一个函数也是一个类型
  def example4[A](a: A): A = a

  //给example4调用
  def example5(i: Int): Int = i

  //内嵌函数
  def example6(int1: Int): Int = {
    def example7(int2: Int): Int = {
      int1 + int2
    }

    example7(int1);
  }

  //匿名函数 注意定义方式 =>
  var example8 = (a: Int, b: Int) => a + b

  //偏应用函数
  def example9(date: Date, string: String): String = "时间：" + date + "----------" + "你所输入的字符串：" + string

  //函数柯里化
  def example10(a: Int, b: Int): Int = a * b //普通Scala函数
  def example11(a: Int)(b: Int): Int = a * b //被柯里化的函数

  def main(args: Array[String]): Unit = {
    //函数传名调用
    time2(time1());
    println("----------")
    time3(time1());

    //指定函数参数名 可以不安顺序传参
    println(sum(b = 10, a = 50))

    //可变参数
    example1("World", "Wide", "Web")

    //递归
    println(example2(100))

    //默认参数值
    println(example3())

    //高阶函数
    println(example4(example5(5)));

    //内嵌函数
    println(example6(5));

    //匿名函数
    print(example8(1, 5));

    //偏应用函数是在调用的时候于其他的不一样
    var date = new Date();
    //非偏应用
    println(example9(date, "打你哟1"))
    println(example9(date, "打你哟2"))
    println(example9(date, "打你哟3"))
    println("----------")
    //偏引用后  _: 俩符号代表偏应用
    var string = example9(date, _: String);
    println(string("打你哟1"));
    println(string("打你哟2"));
    println(string("打你哟3"));

    //函数柯里化
    println(example10(10, 12));
    println(example11(10)(12));
  }
}