02-Scala基础
2.1. 类型系统
2.2. 控制结构与函数
2.2.1. 条件表达式
- if/else语句可以返回一个值，但不用写return关键字
object CH_0201_ConditionalExpression {
def main(args: Array[String]): Unit = {
//if/else语句可以返回一个值，但不用写return关键字
val x = 10
val value = if (x > 10) 1 else 0
println(value)
}
}
- 返回值可以是不同的类型，但可以他们都有共同的父类Any
object CH_0201_ConditionalExpression {
def main(args: Array[String]): Unit = {
//返回值可以是不同的类型，但可以他们都有共同的父类Any
val x = 10
val value = if (x >= 10) "great" else 0
println(value)
}
}
- 如果没有返回值，则用()代替
object CH_0201_ConditionalExpression {
def main(args: Array[String]): Unit = {
//如果没有返回值，则用()代替
val x = 10
val value = if (x > 10) "great" else ()
println(value)
}
}
2.2.2. 块表达式与赋值语句
- 块表达式形式上表现为由{}包含的一系列表达式，块表达式的返回值是最后一个子表达式
object CH_0202_BlockExpressionAndAssignment {
def main(args: Array[String]): Unit = {
val x =10
val x0 = 2
val y = 5
val y0 = 3
val distance = {
val dx = x - x0
val dy = y - y0
//块表达式的返回值是最后一个表达式，且没有return语句
sqrt(dx * dx + dy * dy)
}
println(distance)
}
}
- 块表达式的中的最后一个表达式若是一个赋值语句，则表示该块表达式没有返回值，Scala中没有返回值用Unit表示
object CH_0202_BlockExpressionAndAssignment {
def main(args: Array[String]): Unit = {
val x =10
val x0 = 2
val y = 5
val y0 = 3
//块表达式的中的最后一个表达式若是一个赋值语句，则表示该块表达式没有返回值，Scala中没有返回值用Unit表示
val distance = {
val dx = x - x0
val dy = y - y0
}
println(distance)
}
}
2.2.3. 循环
- while循环
object CH_02003_Loop {
def main(args: Array[String]): Unit = {
//while
var n = 0
while(n < 10){
print(s"$n")
n += 1
}
}
}
- for循环基本形式
object CH_02003_Loop {
def main(args: Array[String]): Unit = {
//for循环的基本形式
var str = "Hello"
for(i <- 0 to str.length - 1){
println(str(i))
}
}
}
- 嵌套循环
object CH_02003_Loop {
def main(args: Array[String]): Unit = {
//嵌套循环
for(i <- 1 to 9; j <- 1 to 9 if(i >= j)){
print(s"$i * $j = ${i * j} ")
if(i == j) {
println()
}
}
}
}
- yield转换
object CH_02003_Loop {
def main(args: Array[String]): Unit = {
//yield转换：收集集合中的元素并生成一个集合
val value = for (i <- 1 to 10 if i % 2 == 0) yield i
println(value)
}
}
2.2.4. 函数
- 定义一个函数：参数类型需要指定值，且只要不是递归函数，需要为函数指定返回值类型
object CH_0204_Functions {
def main(args: Array[String]): Unit = {
val a = abs(-20)
println(a)
}
//定义一个函数：参数类型需要指定值，且只要不是递归函数，需要为函数指定返回值类型
def abs(x:Double)= if (x >= 0) x else -x
}
- 如果有多个表达式，则将其包含在{}内，代码块中最后一个表达式为函数的返回值
def fac(n:Int)={
var r = 1
for(i <- 1 to n) {r = r * i}
r
}
- 使用return需要为函数指定返回值类型
def func01(x:Double):Int={
var a = 10
return a
}
- 递归需要指定指定返回值类型
def func02(x:Int):Int = {
if(x == 1){
x
} else {
x * func02(x - 1)
}
}
5.默认值函数
//默认值函数调用方式：func03()/func03(a="World")
def func03(a:String = "Hello",b:Int = 10) ={
println(s"$a\t$b")
}
6.匿名函数
//函数签名：(String, Int) => Unit
//匿名函数体：(a: String, b: Int) => { println(s"$a\t$b")}
val func04: (String, Int) => Unit = (a: String, b: Int) => {
println(s"$a\t$b")
}
- 嵌套函数:嵌套内的函数的作用域要受限于外部函数的作用域
def func05(a:String)={
def func()={
println(a)
}
func()
}
- 可变参数
//可变参数
def func07(a:Int*)={
for(e <- a){
println(e)
}
//scala迭代语法
//a.foreach((x:Int) => {println(x)})
a.foreach(println(_)) //由于传入的参数只有一个，因此X可以用_代替
a.foreach(println) //println本身也是接受一个传参且不返回值，所以可以直接传入函数
}
9.函数作为参数
def func08(a:Int,b:Int,f:(Int,Int) => Unit)={
val res = f(a,b)
println(res)
}
10.函数作为返回值
//函数作为返回值
def func09(a:String):(Int,Int) => Unit ={
if(a.equals("+")){
_ + _
} else if (a.equals("-")) {
(x:Int,y:Int) => {
x - y
}
} else if (a.equals("*")) {
(x:Int,y:Int) => {
x * y
}
} else {
(x:Int,y:Int) => {
x / y
}
}
}
- 柯里化
def func10(a:String*)(b:Int*) = {
a.foreach(println)
b.foreach(println)
}
