九阴真经--scala流程控制+函数式编程

一、条件循环

• 分支控制有三种：单分支、双分支、多分支
• Scala中if else表达式其实是有返回值的，具体返回值取决于满足条件的代码体的最后一行内容。如果返回类型不同时，取共同的祖先
• Scala可以通过if实现三元运算符

var age:Int = 20

if (age < 18){
  println("小孩儿")
}else if (age >= 18 && age < 35){
  println("青年")
}else{
  println("中年")      
}

var own:String = if (age < 18){
  "小孩儿"
}else if (age >= 18 && age < 35){
  "青年"
}else{
  "中年"
}

var own1:Any = if (age < 18){
  "小孩儿"
}else if (age >= 18 && age < 35){
  "青年"
}else{
  100
}

var own3:String = if (age > 18) "小孩儿" else  "中年"

二、for和while循环

for循环

• 生成范围数据方法：to（闭闭）、until（闭开）
• 循环守卫：即循环保护式（也称条件判断式，守卫）。保护式为true则进入循环体内部，为false则跳过，类似于continue
• 循环步长：通过by规定寻找变量的步数（偏移量）
• 嵌套循环：没有关键字，所以范围后一定要加；来隔断逻辑
• 引入变量：for推导式一行中有多个表达式时，所以要加 ; 来隔断逻辑。for推导式有一个不成文的约定：当for推导式仅包含单一表达式时使用圆括号，当包含多个表达式时，一般每行一个表达式，并用花括号代替圆括号

//打印1到10
for ( i <- 1 to 10){
  print(i + "\t")
}
println()
//打印1到9
for (i <- 1 until 10){
  print(i + "\t")
}
println()
//打印偶数
for (i <- 1 to 10;if i%2 == 0){
  print(i + "\t")
}
println()
//打印1、4、7、10
for (i <- 1 to 10 by 3){
  print(i + "\t")
}
println()
for (i <-1 to 10; j <- 1 to 10){
  print(i * j + "\t")
}
println()
//引入变量
for (i <- 1 to 10; j = i +1){
  print(i * j + "\t")
}
println()

循环打印和反转

//九九乘法表
for (i <- 1 to 9) {
  for (j <- 1 to i) {
    print(i + " * " + j + " = " + i * j + "\t")
  }
  println()
}

//九层妖塔
for(i <- 1 to 18; if i %2 != 0){
  //" " * ((9-i)/2) + "*" * i
  println(" " * ((18-i)/2) + "*" * i)
}

//反转
for (i <- 1 to 10 reverse){
  println(i)

}

while循环

while用法和java基本相同，但是scala没有continue、break关键字，需要借助breakable实现循环中断的功能。

var flag: Int = 10
while (flag > 0) {
  print(s"now is ${flag} \t")
  flag -= 1
}
println()
var flag1 = 10
do {
  print(s"now is ${flag1} \t")
  flag1 -= 1
} while (flag1 > 0)

//break
println()
Breaks.breakable(
  for (i <- 1 to 10) {
    if (i == 7) {
      Breaks.break()
    }
    print(s"now is ${i} \t")
  }
)
println()
println("--------------------------")

三、函数式编程

1、基本语法

 

//参数名提前  :分割
//def 函数名(参数名：参数类型) ：返回值 = {
//  函数提
//}
def myFun(name:String) : String = {
  return name
}

2、函数和方法的区别

• scala的语法允许在任何语法结构中定义任何的语法
• 函数没有重载和重写的概念，方法可以
• 函数定义在方法中，方法定义在类中
• scala函数可以嵌套定义

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

  def myFun(name:String) : String = {
    return name
  }

  def myFun1 (name:String) : String = {

    def myfun2(name : String) : String = {

      return  s"hello ${name}"
    }
    var temp = myfun2("zhangsan")

    return temp + "  " + name;
  }
  println(myFun1("welcome"))
}

def myFun(name:String) : String = {
  return name
}

def myFun(age:Int) : Int = {
  return age
}

def myFun() : Unit = {
}

3、函数定义

 

//（1）函数1：无参，无返回值
def f1 ():Unit={
  println("无参，无返回值")
}
//（2）函数2：无参，有返回值
def f2():String={
  println("无参，有返回值")
  return "hello"
}
//（3）函数3：有参，无返回值
def f3(age:Int):Unit={
  println("有参，无返回值")
}
//（4）函数4：有参，有返回值
def f4(age:Int) : Int = {
  println("有参，有返回值")
  return 18
}
//（5）函数5：多参，无返回值
def f5(name:String,age:Int):Unit={
  println("多参，无返回值")
}
//（6）函数6：多参，有返回值
def f6(name:String,age:Int):String = {
  return s"${name} : ${age}"
}

4、函数参数

• 可变参数
• 如果参数列表中存在多个参数，那么可变参数一般放置在最后
• 参数默认值，一般将有默认值的参数放置在参数列表的后面
• 带名参数

 

def b1(name:String*):Unit={
}

//def b21(age:Int*,name:String):Int={   //编译错误、飘红
//  val age1: Seq[Int] = age
//
//  return age1.head
//}

def b22(name:String,age:Int*):Int={
  val age1: Seq[Int] = age
  return age1.head
}

def b31(name:String,age:Int=18) : String={
  return name
}

def b32(name:String="zs",age:Int) : String={
  return name
}

def b33(name:String,age:Int=18) : String={
  return name
}

b32("j",17)
b32(age = 18)

b33("ss")
b33("ee",36)
b33(name = "kk",age = 16)

5、函数至简原则

（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值

（2）如果函数体只有一行代码，可以省略花括号

（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）

（4）如果有return，则不能省略返回值类型，必须指定

（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用

（6）Scala如果期望是无返回值类型，可以省略等号

（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加

（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略

（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

def f(name: String): String = {
  return name;
}

//（1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
def f1(name: String): String = {
  name
}

//（2）如果函数体只有一行代码，可以省略花括号
def f2(name: String): String = name

//（3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
def f3(name: String) = name

//（4）如果有return，则不能省略返回值类型，必须指定
def f4(name: String): String = return name

//（5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
def f5(name: String): Unit = return name

println(f5(""))

//（6）Scala如果期望是无返回值类型，可以省略等号
def f6(name: String) {
  name
}

//（7）如果函数无参，但是声明了参数列表，那么调用时，小括号，可加可不加
def f7() = println()

f7()
f7

//（8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def f8 = ""

f8
//println(f8()) //编译不报错，允许报错
//（9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略

def f9(f: (String) => Unit): Unit = {
  f("zbb")
}

f9((name: String) => {println(name)})

//（1）参数的类型可以省略，会根据形参进行自动的推导
f9((name)=>{println(name)})
//（2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过1的永远不能省略圆括号。
f9(name => {println(name)})
//（3）匿名函数如果只有一行，则大括号也可以省略
f9(name => println(name))
//（4）如果参数只出现一次，则参数省略且后面参数可以用_代替
f9(println(_))