scala-Unit-3-Scala基础语法2

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

　　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"$date,$message")
  }

  val date = new Date()

  val longMessage = log(date,_:String)

  log(date,message = "HelloHunter")　　//Wed Jan 09 18:36:51 CST 2019,HelloHunter
  longMessage("rebahenmei")　　　　　　//Wed Jan 09 18:36:51 CST 2019,rebahenmei
}

　　解释：1.使用日期Date要导入java的util包。

　　　　　2.App为Scala中的一个特质，可以不写main方法直接运行程序（如Java中的Test、Before）

六、柯理化

　　将原来接受的两个参数的函数变为一个新的接收一个参数的函数的过程叫做柯理化

　　eg.

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

　　　　def sum(s:Int)(b:Int) = a+b

　　这两个方法是等价的。柯理化可将函数的通用性降低，适用性提高。

　　通用性：适用于所有或者很多的情况

　　适用性：适用于一种或几种的情况

七、偏函数

　　被包裹在花阔内没有match的一组case语句，是一个偏函数

　　PartialFunction[A,B]

　　A;参数类型　　　　B:返回值类型

　　偏函数常用于模式匹配

object PartialFunction {
  def func1(str:String):Int={
    if (str.equals("hunter")) 32 else 18
  }

  def func2:PartialFunction[String,Int]={
    //使用偏函数必须使用case
    case "hunter" => 32
    case _ => 18
  }

  def main(args: Array[String]): Unit = {
    println(func1("hunter"))　　//  32
    println(func1("Wyh"))　　　　//18
    println(func2("hunter"))　　//32
    println(func2("Wyh"))　　　　//18
  }
}

　　偏函数类似于Java中的swtich/case语句。