scala---03

package scala05

object scala01_Function {
  def main(args: Array[String]): Unit = {
    def sayHi(name:String):Unit={
      println("sayHi start....")
      println(s"hi $name")
    }

    def sayHi1(name: String): String = {
      println("sayHi start....")
      s"hi $name"
    }
//    调用函数
    sayHi("dalang")
    val jingl: String = sayHi1("jingl")
    println(jingl)
  }

}

 

package scala05

object Scala02_Fun_Method {
  def main(args: Array[String]): Unit = {
//    区别方式一：通过声明时的具体位置来判断
//    如果直接声明在类的对象的下面，这一定是方法
//    如果声明在方法内部的或者函数内部的都称之为函数
    def sayHi(name:String)={
  println("我是函数....")
  println(s"hi $name")
}
//    调用函数
    sayHi("aaa")
    Scala02_Fun_Method.sayHi("jjjj")
    Scala02_Fun_Method.sayHi("jjjj",age=18)
//    区别方式二 方法可以重载 函数不可以
//def sayHi(name: String, age: Int) = {
//  println("我是方法....")
//  println(s"hi $age ... $name ")
//}
//    泣别方式三 函数可以嵌套声明
def sayHi1(name: String) = {
  println("我是函数....")
//  内部声明一个函数 功能就是改名
  def changeName(name:String):String= {
    name +"帅"
  }
  println(s"hi ${changeName(name)}")
  }
//    嵌套函数结构中的内部函数 不能直接在外部调用
    sayHi1("xxxx")
}



  }
//  声明一个方法
  def sayHi(name:String)={
    println("我是方法....")
    println(s"hi $name ")
  }

  def sayHi(name: String,age:Int) = {
    println("我是方法....")
    println(s"hi $age ... $name ")
  }

}

 

package scala05

object scala03_functionargs {
  def main(args: Array[String]): Unit = {
//    可变参数(0--n)多个参数
  def sayHi(names:String*):Unit={

    println(names)
    for (elem<-names){
      println(elem)
    }

  }

      sayHi("zhangsan","lisi")
//如果参数列表中存在多个参数，那么可变参数一般放置在最后
def sayHi1(age:Int,names:String*):Unit={
  println(s" $age $names")
}
//    参数默认值，一般将有默认值的参数放置在参数列表的后面
    def sayHi2(name:String="bejie"): Unit = {
      println(name)
    }

    sayHi2()
    sayHi2("name")

    def sayHi3(name: String = "bejie",age:Int): Unit = {
      println(name)
    }

    def sayHi4( age: Int,name: String = "bejie"): Unit = {
      println(name)
    }
//    带名传参
def sayHi5(name: String = "bejie", age: Int): Unit = {
  println(name)
}
    sayHi5(age = 100)

  }


}

 

package scala05

object scala04_FunctionSimply {
  def main(args: Array[String]): Unit = {
//    定义一个原始函数
    def sayHI(name:String): String = {
      println(s"hi $name")
       s"hi $name" //return
    }

    val wuKOng: String = sayHI("WWW")
    println(wuKOng)
//    常用化简写法：
//    （1）return可以省略，Scala会使用函数体的最后一行代码作为返回值
def sayHI1(name: String): String = {
  println(s"hi $name")
  s"hi $name" //return
}

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


//    （3）返回值类型如果能够推断出来，那么可以省略（:和返回值类型一起省略）
def sayHI3(name: String) = s"hi $name"
    //    特别注意事项：
//    （4）如果有return，则不能省略返回值类型，必须指定返回值使用
//    根据代码块最后一行作为返回值的原则，，，return 不能作为
//def sayHI(name: String)= {
//  println(s"hi $name")
//  return s"hi $name" //return
//}

//    （5）如果函数明确声明unit，那么即使函数体中使用return关键字也不起作用
def sayHI5(name: String): Unit = {
  println(s"hi $name")
  return s"hi $name" //return
}
//    补充
    def sayHI55(name:String):String={
    if (name==null){
     return  "空串" //return 不能省略
    }
      println(s"hi $name")
      s"hi $name"
    }
  }
//    （6）Scala如果期望是无返回值类型，可以省略等号
def sayHI6(name: String) {
  println(s"hi $name")

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

  }
  sayHI7
  sayHI7()

//    （8）如果函数没有参数列表，那么小括号可以省略，调用时小括号必须省略
def sayHI8 = {
  println("hi boy")

}
  sayHI8

//    修改为匿名函数：lambda 表达式（箭头函数）
//    （9）如果不关心名称，只关心逻辑处理，那么函数名（def）可以省略
 val function: String => String = (name: String) => s"hi $name"
  val str: String = function("aaaa")
  private val function1: String => String = (name: String) => s"hi $name"





}

 

package scala05

import sun.text.resources.es.FormatData_es_UY

object scala05_FunctionLambdaSimple {
  def main(args: Array[String]): Unit = {
    //  声明函数
    //    1.没有参数的匿名函数
    val function0: () => String = () => s"hi zhangsan"
    //    2. 有参数
    val function1: (String) => String = (name: String) => s"hi $name"
    val function2: (String, Int) => String = (name: String, age: Int) => s"hi $name $age"


    //    （1
    //    ）参数的类型可以省略
    //    ，会根据形参进行自动的推导
    //    类型的推导是双向的
    val function3: String => String = name => s"hi $name"
    val function4 = (name: String) => s"hi $name"


    //    （2
    //    ）类型省略之后
    //    ，发现只有一个参数
    //    ，则圆括号可以省略
    //    ；其他情况
    //    ：没有参数和参数超过1的永远不能省略圆括号
    //    。
    val function5: String => String = name => s"hi $name"
    val function6: (String, Int) => String = (name, age) => s"hi $name $age"
    //    （3
    //    ）匿名函数如果只有一行
    //    ，则大括号也可以省略

    val function7 = (name: String) => {
      s"hi $name"
    }
    val function8 = (name: String) => {
      println("hello")
      s"hi $name"
    }
    //    （4
    //    ）如果参数只出现一次
    //    ，且按照顺序出现则参数省略且后面参数可以用_代替
    //
    //    ：1.化简之后只有一个下划线
//      有歧义，_单独使用有充当系统默认值含义
    //
    val function9: String => String = name => s"hi $name"
    //    val function10: String => String = name => s"hi $name"
    val function10: (String, Int) => String = "hi" + _ + _
    val str: String = function10("zhangsan", 10)
    val function100: (Int, Int) => Int = (a: Int, b: Int) => a + b
    val function1000: (Int, Int) => Int = _ + _

    //    2.化简后的函数存在嵌套
    val function11: String => Unit = println(_)
    val function12: String => Unit = name=>println(name+"hello") //error

  }


}

package scala05

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

def main(args: Array[String]): Unit = {
  //    将函数作为值进行传递
  val i:Int=100

  def sayHi(name:String): Unit = {
    println(s"hi $name")
  }
//  使用下环线
  val func1=sayHi _
  func1("worke")
//  匿名函数的写法
val hi: String => Unit = sayHi
//  TODO 高阶函数的第一种就是匿名函数的使用
  val function:String=>Unit=(name:String)=>println(s"hi $name")
//  不使用匿名函数  需要两步操作
  val func2 =sayHi _

}
  }

}