一、定义方法、函数、及方法转换为函数

　　1.方法的定义：

　　　　def  方法名（参数1：数据类型，参数2：数据类型...）:返回值类型 ={

 

　　　　}

　　2.定义函数：

　　　　val h1 = (a:Int,b:Int) => {a * b}

　　3.方法转换为函数(在Windows下的命令行操作)

　　　　def m2(a:Int,b:Int):Int =a + b

　　　　m2 _

　　　　然后系统生产：res6:(Int,Int) => Int =(function2)　

　　　　注释：（function2）表示一个函数，并且有两个参数、　　（Int，Int）代表参数列表

　　**方法和函数的区别会单独用一片来整理

 

二、传值调用&传名调用

　　什么是函数式编程？　　A：方法的参数可以是一个函数的编程模型

　　1.传值调用：方法传递的是值，详情见如下代码：　

object AntForest {
		  var energy = 1000

		  def getEnergy():Int={
			energy += 50
			energy
		  }

		  def getManyEnergy(x: Int):Unit={
			for(a <- 1 to 5){
			  getEnergy()
			  println(s"您现在的能量为：$x")
			}
			println(energy)
		  }

		  def main(args: Array[String]): Unit = {
		   getManyEnergy(getEnergy())
		  }
		}

　　解释：先计算getEnergy的值，将值作为参数放在getManyEnery中使用
  　 输出结果：
  　　 您现在的能量为：1050
 　　  您现在的能量为：1050
  　　 您现在的能量为：1050
  　　 您现在的能量为：1050
   　　您现在的能量为：1050
   　　1300

 

　　2.传名调用：将方法作为函数被其他方法调用，详情见如下代码：

　　

object AntForest {
	 var energy = 1000

	 def getEnergy():Int={
	    energy += 50
	    energy
	 }

	def getManyEnergy(x: => Int):Unit={
	    for(a <- 1 to 5){
	    getEnergy()
	    println(s"您现在的能量为：$x")
	    }
	    println(energy)
	 }

	 def main(args: Array[String]): Unit = {
	     getManyEnergy(getEnergy())
	      }
	}    

　　解释：将getEnergy作为函数被getManyEnergy调用
  　 输出结果：
 　　  您现在的能量为：1100
 　　  您现在的能量为：1200
  　　 您现在的能量为：1300
   　　您现在的能量为：1400
   　　您现在的能量为：1500
   　　1500

 

二、可变参数函数与默认参数函数

　　1.可变参数函数：

　　Java中可变参数的函数：public static void m1(String...arg){ }

　　Scala中可变参数函数：def sum(ints:Int*):Unit={ }

object manyPara {
  def sum(ints:Int*):Int={
    var sum = 0
    for(v <- ints){
      sum += v
    }
    sum
  }

  def setName(params:Any*):Any={
    return params
  }

  def main(args: Array[String]): Unit = {
    println(sum(1,3,5,7,9))　　　　//25
    println(setName("Wyh",23,"man"))　　//WrappedArray(Wyh, 23, man)
  }
}

　　2.默认参数函数：

　　如果传递了参数，测试用传递的值。如果不传递参数，测试用默认值

　　

object defaultParam {
  def sum(a:Int=3,b:Int=7):Int={
    a+b
  }

  def main(args: Array[String]): Unit = {
    println(sum())      //10
    println(sum(1,5))   //6
  }
}

　　

三、高阶函数

　　定义：将其他函数作为参数，或其结果是函数的函数　

object higherOrderFunction {
  def getPerson(h:Int => String,f:Int):String={
    h(f)
  }
  def Person(x:Int):String= "我是" + x.toString + "岁的帅哥"

  def main(args: Array[String]): Unit = {
    println(getPerson(Person,18))
  }
}

　　解释：其中getPerson方法的参数为一个函数h、一个变量f，执行体为参数为f的函数h，h(f)，

　　　　在main方法中getPerson方法将Person方法变为函数，与变量18作为参数，

　　执行输出：我是18岁的帅哥

 

四、字符串的格式化输出

　　常规输出方式：val name = "hunter"　

　　　　　　　　　var age = 18

　　　　　　　　　println("name:" + name ",age:" + age)

　　格式化输出：文字插值器（f、s）

　　　　println(f"name = $name,age = $age")　　println(s"name = $name. age = $age")

　　　　println(f"1 + 1 = ${1+1}")　　　　　　　　println(s"1 + 1 = ${1+1}")

 

五、部分参数应用函数

　　如果函数传递所有预期的参数，则表示完全应用了它；

　　如果只传递了所有参数当中的几个，那么见返回部分应用的函数。

　　eg.命令行操作：

　　　　val sum = (a:Int,b:Int) => a+b

　　　　val sum1 = sum(1,_:Int)

　　　　println(sum1(4))　　　　//输出5

　　代码例子如下：

import java.util.Date

object PartParam extends App {
  def log(date:Date,message:String):Unit={
    println(s"$