Scala学习之路之篇二（scala方法与函数）

// ===========scala方法与函数===========
// Scala 有方法与函数，二者在语义上的区别很小。
// Scala 方法是类的一部分，而函数是一个对象可以赋值给一个变量。换句话来说在类中定义的函数即是方法。
// Scala 中的函数则是一个完整的对象，Scala 中的函数其实就是继承了 Trait 的类的对象。
// Scala 中使用 val 语句可以定义函数，def 语句定义方法。
class Test{
  def m(x: Int) = x + 3
  val f = (x: Int) => x + 3
}
// -------------------scala方法-------------------
// ------方法声明格式：
def functionName ([参数列表]) : [return type]
// 如果你不写等于号和方法主体，那么方法会被隐式声明为抽象(abstract)，包含它的类型于是也是一个抽象类型。
// ------方法定义格式：
def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}
// (1).规范化写法:
def addInt(a:Int,b:Int) : Int = {
	var total : Int = a + b
	return total
}
// Unit，是Scala语言中数据类型的一种，表示无值,用作不返回任何结果的方法；

// (2).不写明返回值的类型，程序会自行判断，最后一行代码的执行结果为返回值:
def addInt(a:Int,b:Int) = {
	a+b
}

// (3).省略返回值类型和等于号，返回的是():
def addInt(a:Int,b:Int){
	a+b
} 

// (4).函数只有一行的写法:
def addInt (a:Int,b:Int) = x + y

// ------实例1：
object add{
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}
// ------如果方法没有返回值，可以返回为 Unit，这个类似于 Java 的 void, 实例如下：
object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}
// ------方法调用：
functionName( 参数列表 )    // 1、调用方法的标准格式：
[instance.]functionName( 参数列表 )    // 2、如果方法使用了实例的对象来调用，我们可以使用类似java的格式 (使用 . 号)：
// ------实例2：
object Test {
   def main(args: Array[String]) {
        println( "Returned Value : " + addInt(5,7) );   // 方法调用
   }
   def addInt( a:Int, b:Int ) : Int = {        // 方法定义
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

// -------------------scala函数-------------------
val addInt = (x: Int,y: Int) => x + y 
// 表示定义函数 addInt ,输入参数有两个分别为x,y ,且均为Int类型，返回值为两者的和，类型为Int

// ===============Scala闭包==============
// 闭包是一个函数，返回值依赖于声明在函数外部的一个或多个变量。
// 闭包通常来讲可以简单的认为是可以访问一个函数里面局部变量的另外一个函数。

// 实例：
// 这里我们引入一个自由变量 factor，这个变量定义在函数外面，这样定义的函数变量 multiplier 成为一个"闭包"，
// 因为它引用到函数外面定义的变量，定义这个函数的过程是将这个自由变量捕获而构成一个封闭的函数。
object Test {  
   def main(args: Array[String]) {  
      println( "muliplier(1) value = " +  multiplier(1) )    // 调用闭包
      println( "muliplier(2) value = " +  multiplier(2) )    // 调用闭包
   }  
   var factor = 3                              // 外部变量
   val multiplier = (i:Int) => i * factor      // 闭包
}  

// ===============scala方法与函数的区别==============
// 1、函数可作为一个参数传入到方法中，而方法不行。
object MethodAndFunctionDemo {
  //定义一个方法
  //方法 m1 ，参数f要求是一个函数，函数的参数必须是两个Int类型
  //返回值类型也是Int类型
  def m1(f:(Int,Int) => Int) : Int = {
    f(2,6)
  }

  //定义一个函数f1,参数是两个Int类型，返回值是一个Int类型
  val f1 = (x:Int,y:Int) => x + y
  //再定义一个函数f2
  val f2 = (m:Int,n:Int) => m * n

  //main方法
  def main(args: Array[String]): Unit = {
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)

    println(r1)

    //调用m1方法，并传入f2函数
    val r2 = m1(f2)
    println(r2)
  }
}
// 2、在Scala中无法直接操作方法，如果要操作方法，必须先将其转换成函数。
// 	 有两种方法可以将方法转换成函数：
// 2.1 在方法名称m后面紧跟一个空格和下划线告诉编译器将方法m转换成函数
val f1 = m _
// 2.2 显式地告诉编译器需要将方法转换成函数：
val f1: (Int) => Int = m
// 实例：
object TestMap {

  def ttt(f:Int => Int):Unit = {
    val r = f(10)
    println(r)
  }

  val f0 = (x : Int) => x * x

  //定义了一个方法
  def m0(x:Int) : Int = {
    //传递进来的参数乘以10
    x * 10
  }

  //将方法转换成函数，利用了神奇的下滑线
  val f1 = m0 _

  def main(args: Array[String]): Unit = {
    ttt(f0)

    //通过m0 _将方法转化成函数
    ttt(m0 _);

    //如果直接传递的是方法名称，scala相当于是把方法转成了函数
    ttt(m0)

    //通过x => m0(x)的方式将方法转化成函数,这个函数是一个匿名函数，等价：(x:Int) => m0(x)
    ttt(x => m0(x))
  }
}
// 3、函数必须要有参数列表，而方法可以没有参数列表
def m1 = 100      // 正确

def m2()=100      // 正确

val f1 = () => 100   // 正确

val f2 =    => 100   // 错误

// 4、在需要函数的地方，如果传递一个方法，会自动进行ETA展开（把方法转换为函数）
//  如果我们直接把一个方法赋值给变量会报错。如果我们指定变量的类型就是函数，那么就可以通过编译