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 _
}
}
}