做网站的收钱不管了产品设计公司

1. 定义变量

（变量的类型在变量名之后等号之前声明）

• 不可变变量(val)
  类似于 Java 中的 final 变量，即一旦赋值后，其值不能再被改变。

  val myVal : String = "Foo"
  

• 可变变量(var)
  类似于 Java 中的普通变量，其值可以在程序的生命周期内多次改变。

  var myVar : String = "Foo"
  

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。
所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

val inferredInt = 42  // 编译器推断为 Int
val inferredDouble = 3.14  // 编译器推断为 Double
val inferredString = "Hello, Scala!"  // 编译器推断为 String
val inferredBoolean = true  // 编译器推断为 Boolean

• 多个变量声明
  Scala 中，可以使用逗号分隔、元组解构和 for 推导式等方法同时声明多个变量。
  • 逗号分隔

    val a, b, c: Int = 5
    var x, y, z: Int = 10
    

  • for 推导式

    object ForComprehension {def main(args: Array[String]): Unit = {// 同时声明多个变量用于迭代val numbers = List((1, "one"), (2, "two"), (3, "three"))for ((number, word) <- numbers) {println(s"Number: $number, Word: $word")}// 使用 for 推导式生成新集合val newNumbers = for {(number, word) <- numbers} yield (number * 2, word.toUpperCase)println(s"New Numbers: $newNumbers")}
    }
    

2. 定义方法

格式

def functionName ([参数列表]) : [return type] = {function bodyreturn [expr]
}

案例

object add{def addInt( a:Int, b:Int ) : Int = {var sum:Int = 0sum = a + breturn sum}
}

如果方法没有返回值，可以返回为 Unit，类似于 Java 的 void。

（定义函数，也可认为方法和函数没区别）

class Test{def m(x: Int) = x + 3val f = (x: Int) => x + 3
}

3. 闭包

闭包 是指 一个函数可以捕获外部变量，并在其作用域之外仍然可以使用这些变量。
简单形式

object ClosureExample1 {def main(args: Array[String]): Unit = {var externalVar = 10val closure = (x: Int) => x + externalVarprintln(closure(5))  // 输出 15externalVar = 20println(closure(5))  // 输出 25}
}

复杂形式：闭包作为返回值

object ClosureExample2 {def main(args: Array[String]): Unit = {def makeAdder(adder: Int): Int => Int = {(x: Int) => x + adder}val addFive = makeAdder(5)val addTen = makeAdder(10)println(addFive(3))  // 输出 8println(addTen(3))   // 输出 13}
}

详细解释
makeAdder 是一个 高阶函数，它接收一个整数 adder，返回一个 函数。
返回值类型：Int => Int（表示返回一个 输入 Int，返回 Int 的函数）。
返回的函数 (x: Int) => x + adder：

• 这是一个 匿名函数（Lambda 表达式）。

执行过程总结

步骤	代码	解释
①	makeAdder(5)	adder = 5，返回 (x: Int) => x + 5
②	val addFive = makeAdder(5)	addFive 现在是 (x: Int) => x + 5
③	println(addFive(3))	3 + 5 = 8，输出 8

闭包与函数式编程：
闭包在函数式编程中是一个重要的概念，广泛用于高阶函数、柯里化等技术中。
以下实例，highOrderFunction 函数接受一个函数作为参数。传递的闭包捕获了外部变量 externalVar。

object ClosureExample4 {def main(args: Array[String]): Unit = {def highOrderFunction(f: Int => Int, x: Int): Int = f(x)val externalVar = 5val closure = (x: Int) => x + externalVarprintln(highOrderFunction(closure, 10))  // 输出 15}
}

4. 声明字符串

val s = "Hello World!";或val s:String = "Hello World!";

5. 声明数组

var arr:Array[String] = new Array[String](3)或var arr = new Array[String](3)或var arr = Array("Runoob", "Baidu", "Google")

为数组元素赋值

arr(0) = "Runoob"

6. 声明集合

// 定义整型 List
val x = List(1,2,3,4)// 定义 Set
val x = Set(1,3,5,7)// 定义 Map
val x = Map("one" -> 1, "two" -> 2, "three" -> 3)// 创建两个不同类型元素的元组
val x = (10, "Runoob")// 定义 Option
val x:Option[Int] = Some(5)

7. 异常处理

import java.io.FileReader
import java.io.FileNotFoundException
import java.io.IOExceptionobject Test {def main(args: Array[String]) {try {val f = new FileReader("input.txt")} catch {case ex: FileNotFoundException => {println("Missing file exception")}case ex: IOException => {println("IO Exception")}} finally {println("Exiting finally...")}}
}

---

over~