scala

SCALA复习大纲

1.   变量定义格式是什么？可变不可变变量定义格式。Scala中的变量定义格式如下：

• 可变变量：在Scala中，可变变量使用var关键字定义。可变变量可以被重新赋值，因此是可变的。格式如下：

scala

var variableName: DataType = initialValue

例如：

scala

var myVar: Int = 42

var myMutableList: List[String] = List("apple", "banana", "orange")

• 不可变变量：不可变变量使用val关键字定义。一旦赋值后，不可再更改其值，因此是不可变的。格式如下：

scala

val variableName: DataType = initialValue

例如：

scala

val myVal: String = "Hello, Scala!"

val myImmutableList: List[Int] = List(1, 2, 3)

这就是Scala中可变和不可变变量的一般定义格式。

2.   一般的代码段输出， 比如定义变量利用条件语句看输出结果。

// 定义变量

val myVariable = 10

// 使用条件语句

if (myVariable > 5) {

  println("变量大于5")

} else {

  println("变量小于或等于5")

}

这段代码首先定义了一个名为 myVariable 的变量，并将其设置为 10。然后，它使用一个条件语句 (if-else) 来检查 myVariable 的值。如果 myVariable 大于 5，则输出 "变量大于5"；否则，输出 "变量小于或等于5"。

3.   For 循环如何遍历集合元素。

val myCollection = List(1, 2, 3, 4, 5)

for (element <- myCollection) {

  println(element)

}

在上面的代码中，我们首先定义了一个名为 myCollection 的集合，它包含了一些整数。然后，我们使用 for 循环遍历集合中的每个元素，并将其打印到控制台上。

在 Scala 中，for 循环通常使用模式匹配和递归结构来处理集合和列表等数据结构。如果集合中的元素是可迭代的，例如列表或数组，那么可以使用 for 循环来遍历它们。如果集合中的元素是单一类型或对象，那么可以使用其他 Scala 语法结构来遍历它们。

需要注意的是，Scala 中的集合类型通常不是严格意义上的集合，而是包含元素的集合对象。因此，在 Scala 中可以使用多种集合类型来存储和处理数据，包括 List、Set、Map 等。根据具体的数据结构和需求，可以选择合适的循环结构来遍历集合元素。

4.   不可变字符串如何定义？

// 使用 val 关键字定义不可变字符串

val immutableString: String = "这是一个不可变字符串"

// 你也可以省略类型声明，让编译器自动推断类型

val anotherImmutableString = "另一个不可变字符串"

在上面的例子中，immutableString和anotherImmutableString都是不可变的字符串。由于Scala中的String类是不可变的，一旦字符串被创建，就不能被修改。使用val关键字确保我们不能重新赋值给这些变量，从而使它们保持不可变性。

5.   在 scala 中如何定义函数？

// 定义一个简单的函数，接受两个参数并返回它们的和

def add(x: Int, y: Int): Int = {

  x + y

}

在这个例子中：

• add 是函数的名称。
• (x: Int, y: Int) 是函数的参数列表，其中 x 和 y 是参数的名称，Int 是它们的类型。
• : Int 表示函数的返回类型是 Int。
• = 后面是函数体，定义了函数的具体操作。

你可以调用这个函数并得到结果：

val result = add(3, 5)

// 现在 result 的值是 8

6.   如何定义数组？ 格式是什么？

// 定义一个整数数组

val myArray: Array[Int] = Array(1, 2, 3, 4, 5)

// 定义一个字符串数组

val myStringArray: Array[String] = Array("apple", "banana", "orange")

// 创建一个空数组，指定长度

val emptyArray: Array[Double] = new Array[Double](10)

在上述例子中：

• val 用于声明不可变的变量。
• myArray 和 myStringArray 是数组的名称。
• Array[Int] 和 Array[String] 分别表示整数数组和字符串数组的类型。
• Array(1, 2, 3, 4, 5) 和 Array("apple", "banana", "orange") 是初始化数组时的值。
• new Array[Double](10) 创建了一个包含10个元素的双精度浮点数数组，所有元素初始化为零。

你可以根据需要调整数组的类型和初始值。

7.   Scala 中合法的标识符

在Scala中，合法的标识符必须遵循以下规则：

1. 字母、数字和下划线：标识符可以由字母（包括大写和小写）、数字和下划线组成。
2. 以字母或下划线开头：标识符必须以字母或下划线开头。
3. 大小写敏感：Scala是大小写敏感的，因此大写字母和小写字母被视为不同的字符。
4. 不得使用Scala关键字：不能使用Scala中的关键字（例如if、else、while等）作为标识符。

以下是一些合法的标识符示例：

• myVariable
• counter_1
• _result
• MyClass
• scala_version

请注意，虽然可以使用Unicode字符作为标识符，但通常建议使用ASCII字符以确保更好的可读性和互操作性。

8.   如何在 scala 中中断循环跳到下一次循环？

在 Scala 中，可以使用 break 关键字来中断循环并跳到下一次循环。

例如，以下是一个使用 for 循环的示例，演示如何中断循环并跳到下一次循环：

for (i <- 1 to 5) {

  if (i == 3) {

    break // 退出循环并跳到下一次循环

  }

  println(i)

}

在这个例子中，当 i 等于 3 时，循环会立即停止，并跳到下一次循环。循环将继续从 i = 4 开始执行。

另外，你也可以使用 return 关键字来中断函数并跳到下一次迭代。例如：

def myFunction(n: Int): Int = {

  for (i <- 1 to n) {

    if (i == 3) {

      return i // 退出函数并跳到下一次迭代

    }

    println(i)

  }

  // 如果循环没有中断，则返回最后一个迭代的值

  42

}

在这个例子中，当 i 等于 3 时，函数会立即停止并返回 i 的值。如果没有中断，函数将返回 42。

9.   scala 程序的编译和运行顺序？

Scala程序的编译和运行顺序如下：

1. 编写Scala源代码：使用文本编辑器或集成开发环境（IDE）编写Scala源代码。
2. 编译Scala源代码：使用Scala编译器将源代码编译成字节码文件（.class文件）。这一步将源代码转换为可在Java虚拟机（JVM）上运行的字节码。
3. 运行Scala程序：通过JVM来执行编译后的字节码文件。JVM会加载字节码文件并执行其中的指令。

在开发过程中，通常会使用IDE或构建工具（如sbt、Maven或Gradle）来自动化编译和运行Scala程序的过程。这些工具可以监视源代码文件的变化，并在文件更改时自动重新编译程序，以便快速进行开发和调试。

10. 创建一个类时使用哪个关键字？

在Scala中，创建类时使用关键字class。例如：

scala复制代码

	class MyClass {
	// 类体
	}

此外，Scala还支持单例对象和伴生对象的语法。单例对象使用object关键字创建，而伴生对象则使用class和object关键字一起定义。例如：

scala复制代码

	object MySingleton {
	// 单例对象体
	}
	class MyClass {
	object MyInnerObject {
	// 伴生对象的内部对象体
	}
	}

伴生对象中的内部对象使用object关键字定义，类似于单例对象。

11. scala 程序的编译指令

在Scala中，编译指令通常用于编译Scala源代码。以下是一些常用的Scala编译指令：

1. scalac: 这是Scala编译器的主命令，用于将Scala源代码编译成字节码文件。例如，scalac HelloWorld.scala将编译名为HelloWorld.scala的源文件。
2. scalac -classpath: 该指令用于指定类路径，以便编译器能够找到所需的类文件和库文件。例如，scalac -classpath /path/to/classes HelloWorld.scala将使用指定的类路径来编译HelloWorld.scala。
3. scalac -d: 该指令用于指定输出目录，编译后的字节码文件将输出到指定的目录中。例如，scalac -d /path/to/output HelloWorld.scala将编译HelloWorld.scala并将字节码文件输出到/path/to/output目录中。
4. scalac -g: 该指令用于生成带有行号表和本地变量的字节码文件，这有助于调试。例如，scalac -g HelloWorld.scala将使用-g选项编译HelloWorld.scala。
5. scalac -optimize: 该指令用于启用优化，以提高生成的字节码的性能。例如，scalac -optimize HelloWorld.scala将使用-optimize选项编译HelloWorld.scala。

这些是常用的Scala编译指令，还有其他一些选项可用于更高级的用途。要查看完整的编译指令列表和它们的详细说明，请查阅Scala文档或运行scalac -help命令。

12. scala 程序的运行指令

在Scala中，运行编译后的字节码文件可以使用Scala解释器或JVM。以下是常用的Scala运行指令：

1. scala: 该指令用于启动Scala解释器，可以直接运行Scala源代码。例如，scala HelloWorld.scala将运行名为HelloWorld.scala的源文件。
2. scala -classpath: 该指令用于指定类路径，以便解释器能够找到所需的类文件和库文件。例如，scala -classpath /path/to/classes HelloWorld将使用指定的类路径来运行HelloWorld类。
3. java -jar: 如果Scala程序被打包为JAR文件，可以使用Java命令来运行它。例如，java -jar myprogram.jar将运行名为myprogram.jar的JAR文件。

这些是常用的Scala运行指令，还有其他一些选项可用于更高级的用途。要查看完整的运行指令列表和它们的详细说明，请查阅Scala文档或运行scala -help命令。

13. 针对编译完成的 class 文件，直接用记事本文件打开，出现乱码现象， 因此如何才能将class 文件内容编程我们能看懂的代码？

class 文件是 Java 字节码文件，它不是源代码文件，因此无法直接用记事本打开并阅读。要将其转换为可读的源代码，你需要使用反编译器。反编译器可以将字节码文件转换回类似源代码的格式，但请注意，由于字节码与源代码之间的转换是有限的，反编译后的代码可能并不完全等同于原始源代码。

在 Scala 中，你可以使用一些反编译器来查看 class 文件的内容。以下是几个常用的反编译器：

1. JD-GUI：JD-GUI 是一个独立的图形化反编译器，可以直接打开 class 文件并显示反编译后的代码。它支持多种编程语言，包括 Java 和 Scala。
2. FernFlower：FernFlower 是 IntelliJ IDEA 使用的反编译器，可以将字节码转换为可读的 Java 或 Scala 代码。你可以在命令行中使用它，或者将其集成到你的 IDE 中。
3. JAD：JAD（Java Decompiler）是一个流行的反编译器，可以将字节码转换为 Java 源代码。虽然它不是专门为 Scala 设计的，但也可以用于查看 Scala class 文件的内容。

使用反编译器时，请注意版权和法律问题。反编译代码可能受到法律限制，因此请确保你有权查看和反编译目标代码。

14. Scala 中如何创建一个类的实例对象？

在Scala中，创建类的实例对象与在Java中类似，你可以使用new关键字。例如，假设我们有一个名为MyClass的类：

scala复制代码

	class MyClass {
	// 类体
	}

要创建这个类的实例对象，你可以这样做：

scala复制代码

val myObject = new MyClass()

在上述代码中，myObject是实例对象的变量名，你可以根据需要选择任何名称。

另外，如果你希望使用伴生对象（companion object）来创建实例，你可以这样做：

首先，定义一个伴生对象：

scala复制代码

	object MyClass {
	// 伴生对象的内部方法或属性
	}

然后，你可以使用伴生对象的名称来创建类的实例：

scala复制代码

val myObject = MyClass()

在上述代码中，Scala会自动调用伴生对象中的apply方法来创建实例对象。如果你在伴生对象中定义了apply方法，那么你就可以直接使用伴生对象的名称来创建实例对象，而不需要显式地调用new关键字。

15. 在 Scala 中，如何定义一个抽象类？

在 Scala 中，你可以使用 abstract 关键字来定义一个抽象类。抽象类可以包含抽象成员（没有具体实现的成员）和非抽象成员。以下是一个示例：

scala复制代码

	abstract class AbstractClass {
	// 抽象成员
	def abstractMethod: Int
	// 非抽象成员
	def concreteMethod: String
	}

在上述示例中，AbstractClass 是一个抽象类，它包含一个抽象方法 abstractMethod 和一个具体方法 concreteMethod。需要注意的是，你不能直接实例化抽象类。为了创建一个 AbstractClass 的实例，你需要提供一个具体的实现来满足所有的抽象成员。例如：

scala复制代码

	class ConcreteClass extends AbstractClass {
	def abstractMethod: Int = 42
	def concreteMethod: String = "Hello, world!"
	}

在上述示例中，我们创建了一个名为 ConcreteClass 的具体类，它继承了 AbstractClass 并提供了所有抽象成员的具体实现。现在，我们可以创建 ConcreteClass 的实例：

scala复制代码

	val instance = new ConcreteClass()
	println(instance.abstractMethod) // 输出 42
	println(instance.concreteMethod) // 输出 "Hello, world!"

16. 在 Scala 中，查看程序当前运行路径的指令是？

在 Scala 中，你可以使用 System.getProperty("user.dir") 来获取程序当前运行的路径。这个方法会返回一个字符串，表示当前的工作目录。示例如下：

scala复制代码

	val currentPath = System.getProperty("user.dir")
	println(currentPath)

这段代码将打印出程序当前运行的路径。

17. 关于 lazy 变量描述

在Scala中，lazy关键字用于定义惰性变量。惰性变量只有在真正使用时才会被初始化，也就是说，它只有在第一次访问时才会计算其值，并在之后缓存该值。这有助于减少不必要的计算和可能的重复计算，提高程序的性能。

与Java中的延迟加载（lazy loading）不同，Scala中的惰性变量是语言级别的特性，提供了更好的控制和语义清晰度。使用lazy关键字修饰的变量，只有在其首次被访问时才会计算其值，这有助于减少不必要的计算和可能的重复计算。

值得注意的是，Scala中的惰性变量只能是不可变变量（val），因为可变变量（var）在程序运行过程中可能会被重新赋值，这与惰性变量的语义相矛盾。另外，惰性变量必须是不可变变量，以确保它们在首次访问时只被初始化一次，并且之后保持不变。

在实践中，惰性变量在需要延迟计算或减少不必要的重复计算时非常有用。例如，在处理大型数据集或执行昂贵的计算操作时，使用惰性变量可以避免不必要的开销和性能损失。

总之，Scala中的惰性变量是一种强大的工具，可以帮助优化程序的性能和减少不必要的计算。通过合理地使用惰性变量，可以编写更加高效和可靠的代码。

18. 直接实现截取后四位功能的函数

在Scala中，你可以使用字符串的 takeRight 方法来截取字符串的后四位。这是一个简单的例子：

scala复制代码

	def lastFourDigits(str: String): String = {
	if (str.length < 4) {
	return str
	} else {
	return str.takeRight(4)
	}
	}

这个函数首先检查输入字符串的长度是否小于4，如果是，则直接返回原字符串。否则，它会使用 takeRight 方法来截取字符串的后四位，并返回结果。

你可以这样调用这个函数：

scala复制代码

	println(lastFourDigits("1234567890")) // 输出 "6789"
	println(lastFourDigits("1234")) // 输出 "1234"

19. Scala 的关键特性（最少列举三个）

Scala 是一种强大的编程语言，具有许多关键特性，以下是其中三个：

1. 面向对象和函数式编程的混合：Scala 允许开发者同时使用面向对象和函数式编程范式。这意味着你可以使用对象、类、继承等面向对象的特性，同时也可以利用函数式编程的优势，如不可变性、高阶函数和简洁的代码。
2. 静态类型：Scala 是静态类型的语言，这意味着类型是在编译时确定的，这有助于减少运行时的错误，并允许编译器提供类型相关的优化。
3. 扩展性：Scala 的设计允许通过添加新的语言结构来轻松扩展其功能。这使得在实践中，某个领域特定的应用程序开发往往需要特定于该领域的语言扩展时，Scala 能够很好地满足这些需求。

此外，Scala 还有许多其他重要的特性，如强大的类型系统、模式匹配、并发模型等。这些特性使得 Scala 在开发复杂系统时非常强大和灵活。

20. Scala 主要包括哪些循环语句？并阐述 while 循环和 do while 循环的区别

Scala 语言中常用的循环语句包括：

1. for 循环：类似于其他语言的 for 循环，用于迭代一个集合（如列表、元组等）或一个序列。

scala复制代码

	for (i <- 1 to 10) {
	println(i)
	}

1. while 循环：只要给定的条件为真，就会重复执行一段代码。

scala复制代码

	var i = 0
	while (i < 10) {
	println(i)
	i += 1
	}

1. do while 循环：与 while 循环类似，但至少会执行一次，然后再检查条件。

scala复制代码

	var i = 0
	do {
	println(i)
	i += 1
	} while (i < 10)

while 循环和 do while 循环的区别：

1. 执行次数：while 循环在条件为假之前可能不会执行任何迭代，而 do while 循环至少会执行一次迭代，然后再检查条件。
2. 代码块的位置：在 while 循环中，代码块在条件检查之前，而在 do while 循环中，代码块在条件检查之后。这意味着 do while 循环的代码块至少会被执行一次，无论条件是否为真。
3. 逻辑流程：do while 循环更适合用于至少需要执行一次的情况，因为无论条件如何，代码块都会被执行一次。而 while 循环则更适合于在满足某个条件时重复执行的情况。

21.  求和功能： -1+2-3+4-5+6-7+8...100

以下是使用Scala语言实现求和功能的代码：

scala复制代码

	def sum(n: Int): Int = {
	var result = 0
	for (i <- 1 to n) {
	if (i % 2 == 0) {
	result += i
	} else {
	result -= i
	}
	}
	result
	}
	println(sum(100)) // 输出结果为 -50

在这个代码中，我们定义了一个名为sum的函数，它接受一个整数参数n，并返回一个整数。在函数中，我们使用一个变量result来保存求和的结果，然后使用一个for循环迭代1到n的所有整数。在循环中，如果当前迭代到的数是偶数，我们将它加到result中，否则将它从result中减去。最后，我们返回result作为函数的返回值。

在主函数中，我们调用sum函数并传入参数100，然后打印出函数的返回值。根据题目要求，我们可以看到最终的结果为-50。

22. 用户登录功能， 输入用户名和密码要求最多输入次数不超过 3 次

在Scala中，你可以使用Option来处理可能的空值，使用for循环来实现最多输入三次的要求。以下是一个简单的实现：

scala复制代码

	object Main {
	def main(args: Array[String]): Unit = {
	var username: Option[String] = None
	var password: Option[String] = None
	var attempts = 3
	while (attempts > 0 && (username.isEmpty || password.isEmpty)) {
	val inputUsername = readLine("请输入用户名: ")
	val inputPassword = readLine("请输入密码: ")
	username = Some(inputUsername)
	password = Some(inputPassword)
	attempts -= 1
	}
	if (attempts == 0) {
	println("您已经达到了输入次数上限")
	} else if (username.getOrElse("") == "admin" && password.getOrElse("") == "password") {
	println("登录成功!")
	} else {
	println("用户名或密码错误")
	}
	}
	}

在这个程序中，我们首先创建两个Option变量来存储用户名和密码。然后，我们使用一个while循环来检查是否还有输入次数，以及用户名和密码是否都已输入。如果还有输入次数，并且用户名或密码为空，我们就提示用户输入用户名和密码，并将输入的值赋给相应的变量。然后，我们将输入次数减一。如果用户名和密码都已输入，或者没有输入次数了，我们就跳出循环。最后，我们检查用户名和密码是否正确。如果都正确，就打印"登录成功!"，否则就打印"用户名或密码错误"。如果达到了输入次数上限，就打印"您已经达到了输入次数上限"。

23. 针对以下 pig 类的定义，在类的实例化及属性修改的过程中 p1.color=“blue”报错，请重 新书写以下类定义、类的实例化及类属性修改的代码， 使其能实现 p1.color=“blue”修改 的效果。

首先，我需要知道你原始的 Pig 类定义。不过，基于你给出的描述，我猜想你的类可能是这样的：

scala复制代码

	class Pig {
	var color: String = "red" // 默认颜色为红色
	}

然后你创建了一个 Pig 对象 p1，并尝试修改它的 color 属性为 "blue"，但出现了错误。

下面我将展示如何正确地定义类、实例化和修改属性：

scala复制代码

	class Pig {
	var color: String = "red" // 默认颜色为红色
	}
	val p1 = new Pig() // 实例化
	p1.color = "blue" // 修改属性 color
	println(p1.color) // 输出: blue

注意几个关键点：

1. 类属性 color 的默认值是 "red"。
2. 使用 val 关键字创建对象 p1，这意味着 p1 是不可变的。如果你想在之后修改 p1 的值，你应该使用 var。
3. 你可以通过对象名来访问和修改其属性。例如，p1.color 可以获取或设置 p1 的 color 属性。
4. 在上面的代码中，我们没有看到任何错误，因为代码是正确的。如果你遇到了错误，请提供更详细的错误信息或完整的代码示例，以便我能更好地帮助你。

编译过程

第一步完成程序编写

第二步在命令行中使用scalac编译生成class文件

scalac HelloWorld.scala

第三步使用scalap进行反编译（用来查看编译语句）

scalap HelloWorld.scala

运行

scala HelloWorld

java-scala比对

指定编译和运行路径：

1实践

例如：体会指定编译和运行路径（在主文件中遇到一个新类-Person）

第一步复现

D:\study\2023-2024年第一学期\大数据编程基础\Scalaworkspace\HelloWorld

object HelloWorld extends App{
    println("hello world!")}

第二步

scalac HelloWorld.scala

第三步

scala HelloWorld

第四步

object HelloWorld extends App{
    println("person hello world!")

def say(person:Person){

}

}

第五步 定义一个Person类（文件名为Person.scala）

class Person(var name:String){
}

第六步

scalac HelloWorld.scala

第七步

scalac Person.scala

第八步

scalac HelloWorld.scala

第九步

scala HelloWorld.scala

指定编译运行脚本的实践

scala -cp命令强制指定

第一步

修改Person.class保存路径为C:\test\classes，输入scalac HelloWorld.scala

第二步

当编译的文件和类文件不在一个路径时，可以使用scalac -cp 命令强制指定类文件所在的目录，输入 scalac -cp C:\test\classes HelloWorld.scala

第三步

运行脚本Scala HelloWorld

第四步

Scala -cp C:\test\classes HelloWorld

第五步

输入完整的Scala -cp

scalac -cp C:\test\classes;C:\test HelloWorld

总结：

一、主子文件运行次序

第一步先编译子文件

第二步编译主文件

第三步运行住脚本

二、如果编译文件不在一个路径下如何运行住脚本文件的步骤

第一步先在相应的目录下生成子文件的编译文件

第二步编译主文件

反编译三种

1第一步使用记事本打开Person类

第二切换目录Person.scala编译文件的目录下

第三输入scalap Person

第四步使用Javap反编译生成Scala的类文件，让我们能够理解Scala的运行机制。

javap Person                                                                                                     

如果我们想反编译scala那么使用scala命令，如果我们想知道scala命令对应的java文件那么我们使用javap完成反编译。

2在编译过程中了解代码的执行方式

例如：创建一个文件尝试使用scala了解程序的执行过程。

第一步创建一个scala脚本，定义control类

class control{

        for(i<-1 to 5)println(i)

}

第二步通过scala生成编译文件，在命令行中输入scalac -Xprint:parse control.scala

第二种编译方式——解释器的使用

启动——Scala

a.getClass

s+tab

scala解释器的使用

实践
例如:使用REPL命令交互编程
val x,y=1
x+y
val a=Array(1,2, 3)
a. sum
a. getClass
val s="hello scala”
s. +tab键 //让我们了解字符串可以完成哪些运算
s. sum
//让学符串完成求和运算
s.c +tab键 /让我们了解字符事以c开头的方法有哪些?
val a="4''
 to +tab键 //让我们了解字符串以开头的方法有哪些?

a.toInt//将a字符串强制转换为整型数据类型

三、常见命令

第三步切换相应文件存放路径，然后再启动scala解释器，输入new Person("scala")。

目的：实现scala对象定义and参数。

REPL常见命令的应用

1.实践
例如:尝试使用解释器中的命令
第一 步基于之前创建好的Person类
class Person(var name:String) {
第二步创建一个对象并完成参数的传递
new. Person(" scala")
通过测试出现报错问题! 因为我们解释器在启动前没有正确的指定person类的脚本文件和编译文件保存位置因此出现报错问题。
按下contrl +c键退出解释器
第三步切换相应文件存放路径，然后再启动sca1a解释器输入

new Person(" scala")
第四步查看name属性，在解释器中输入
res0. name
第五步使用Ctr1 +C退出解释器
第六步修改Person. class (即Person. scal a类脚本的编译文件)保存为c:\test\classes目录下。这样设计的用处在于，让大家体会脚本文件和编译文件不在一 个路径下的对象赋值的操作过程。

第七步实践二下两文件在不同路径下的对象赋值错误操作
(1)你的目录切换为c: test
(2)创建一个新目录为classes,把Person. class确认保存到c: \test\classes目录下
(3)在命令行输入scala进入解释器。
(4)_输入对象赋值语句
new Person(" scala")

(5)再次使用Ctr1 +C退出解释器
第八步在启动解释器的过程中，通过加入-cp可选项解决脚本文件和编译文件不在一 个路径下的问题。再次启动解释器输人scala - cp c: \test\classes

第九步再次输入对象赋值语句
new Person(" scala")

第十步
help
第十一步 使用load命令加载定义好的scala文件
:load c: test/Person. scala

9月20日
在Scala解释器中输入if··· else···语句

1、实践

例如：尝试在解释器中运行

第一步尝试输入一条简单的条件语句
if(false)｛｝
第二步尝试在解释中输入多条条件语句
if (false)
println("I am false")

第三步尝试在解释器中输入:paste.然后按下[Enter]键，目的是让解释器进入粘贴模式。

第四步尝试在解释器粘贴模式中输入多条条件语句查看运行结果
if(false) {}
println(" false")
if (false)
println(" I am false")
else
println ("I am true")

回车
按下ctrl+D键

标识符定义:

一、标识符是用卢编程时使用的名字，用于给变量、常量、函数、语句块等命名，以建立起名称与使用之间的关系。
二、作用
Scala组件都需要名称。用于对象，类，变量和方法的名称。

三、支持标识符:
字母数字标识符、运算符标识符、混合标识符和字面识别符。
注意事项:
不能以数字开头，不能是Scala中的关键字。
符号"$"在Scala. 中也看作为字母。然而以"$ "开头的标识符为保留的Scala编译器产生的标志符使用，应用程序应该避免使用“$“开始的标识符，以免造成冲突。

四、标识符分类
1、字母数学标识符以字母或下划线开头，后面可以有更多的字母，数字或下划线。$字符是Scala中的保留关键字，不应在标识符中使用。
2.运算符标识符
运算符标识往由一个或多个运算符字符组成。运算符字符是可打印的ASCII字符， 如: +,::：，:->($co1 on$minus$greater)等。
3.混合标识符
混合标识行电字母数字标识符组成，后面跟着-个下划线和一个操作符标识符。
4.字面识别符
个文字标识符是一-个随意的字符串，包含在后面的反引号(...)中。

●以下哪些是合法的标识符

√A.age
B.abc# @
√C.salary
D.a b
√E.name_ +
√F. _value
√G.__1 _value
合法但不建议√H.$salary
关键字I.yield
J.123abc
K.def
L.implicit
√M.For
N.-salary

分号

1.分号是表达式的分隔符，Scala自动推断分号。.
2. Scala是一种面向行的语言，其语句可能以分号(:)结尾,分号推断规则: .
如果一行只有一个表达式，则分号可选
如果一-行只有多个语句或表达式，则分号必须填写
3.注意
自动推断规则，不被当成分号处理，
如果当前行以一个不能结尾的词结尾，如英文句号或中辍操作符。
例如:如果x=2, y=3, 求z的值
例如:分号实践练习。
第一步进入解释器
scala

第二步在解释器中输入检验- - 下Sca1a中在一 -行输入多个表达式时是否可以不输分号。输入
val a=2 println(" a=" +2)
第三步使用分号修订以上语句
val a=2;println("a=" +2)
第四步：输入:paste并按下[Enter]键
val x=1
val y=2;
val z1=x+y
val z2=x

+y
val z3=x
val z4=(x
+y)

第五步

println("z1="+z1)
println("z2=" +z2)
println("z3="+z3)
println("z4="+z4)

第六步ctrl+D退出

第七步 输入:paste并按[Enter] 键,再次进入粘贴模式。输入如下代码:
val x=1
val y=2;
val z=
x+y
def out(s:String)={
        println( "String= "+s)

}
out( "scala" )

第八步：输入:paste并按下[Enter] 键。
class Person{
def sayHello(){println("hello scala")}
}
new Person().
sayHello()
按下CtrI+D

Scala的常量与变量

课程任务
●通过编程,完成Scala与Java的常量与变量的对比

Scala的可变和不可变变量

变量定义:是一种使用方便的占位符,用于引用计算机内存地址,
变量创建后会占用一定的内存空间。
●变量的作用:访问和修改内存数据。
变量声明
●var:声明可变变量
●val:声明不可变变量
变量的类型声明
●var:var变量名:类型
●val:val变量名:类型
●声明多变量
●val|var变量1,变量2，... =变量值

课程练习
现场练习
●以下哪些是合法的语句1、4
√1.val a=10
2.var b:String=100
3. val s = "hello";
    s= “您好”
√4. var age = 10;
      age=20

课程示例
现场示例
●分别使用Val和Var定义一个变量name.
●使用val同时声明多个变量

示例名称: Scala的变量定义和修改

(1)启动Scala解释器
(2)输入val name="scala "
并按[Enter] 键,可以看到变量定义成功,并且成功推
断出其变量类型为String。

(3)输入name= "java" 并按[Enter] 键,结果报错,原因就是用val声明的变量值。

(4)如果想修改变量值,使用var定义变量。输入var name= "scala" 并按[ Enter ]
键,结果定义成功,接着输入name= "java" 并按下[Enter] 键,可以看到变量值
被成功修改。

(5)使用val同时声明多个变量。输入val a,b= 3并按[ Enter]键,可以看到成功声明
了两个整型变量a、b并均赋值为3。

(6)使用var同时声明多个变量。输入var x,y= "scala" 并按[ Enter]键，可以看到
成功声明了两个字符串变量x、y并均赋值为scala。

(7)修改变量值的类型,使其与声明变量时指定的类型不同。输入var
name="scala"
并按[Enter]键声明一个字符串类型的变量name ,接着输入name=2并按[ Enter
]键,结果提示类型不匹配。

注意:
声明变量时指定的数据类型与所赋值的数据类型一定要匹配。

第一，va1完成变量赋值之后，数据值不能修改。第:二声明变量确定數据类型之后，數据类型不能修改。

任务十 Scala变量内存结构

Scala的内存结构

深入Scala引用变量的内存  栈、堆

1、变量被分成三个部分：名、地址、存储数据内存空间。在JVM中变量和变量的地址还有数据是分开存储的，整个内存被分成两个部分“栈”和“堆”。

2、栈主要存储引用的地址即内存空间地址。

     堆存的是内存空间即放数据的地方。

3、每一次声明的变量都会被分配“堆”里的一部分内存空间，并为该部分内存空间分配一个标号即内存空间的地址，该地址和内存变量存储在“栈”里面。

4、用val声明的变量在最开始指向一个内存空间并不可以再引用其他内存空间（水泥桥）

        用var声明的变量在最开始指向一个内存空间并可以再引用其他内存空间（浮桥）

val person= new Person("yangzi",20,"girl")

 class Person{
     val name="scala"
     val sex="wo"
     var age=20
     }

val person=new Person

person.name= "scala"

person.age= 30

person= new Person

5.实践(识别未完善)
例如:定义一个数组array,数组里有scala、java和go三个字符串，川两种方式实现下面要求:
将数组array里面的字符中改为python、rust和c三个字符中
第一 .步用va1定义一个数组。输入val array=Array(" java". "scala","go")并按 [Enter]键，可以看到数组定义成功。
第二步将一个新的数据赋给上一 步的变量array,查看能不能实现对数组元素的替换。输入array-Array(" python"," go",' rust")并按[Enter]键，结
果提示报错。
第三步为了实现对数组元素的修改，可以逐一 为数组中的每- -个元素重新进行赋值。依次输入array(0)=“python”、array(1)=“rust"、array
(2)=' c开按回车键。
array(0)=”,python"
array(1)=”rust
array (2)=
第四步验证数组中的元素是否已被修改，只需把数组变量array赋给新变量a，查看变量a的内容即可，输入val a=array并按 [Enter]键，可以看到变量a
中数组元素已经修改完成。
第五步使用var创建数组，然后重新赋值数组变量。输入var array-Array(“java" ,”scala" ,”go”)并按[Enter]键，成功定义一一个数组: 然后输
入array-Array(" python",C"," ryst )并按[Enterl键，看到数组已经重新赋值。
var array-Array( java. 。”scala
go° )
array-Array(" python'，"c' ”，”rust' )

第六步要想验证数据组重复值是否成功，只需逐个访问这个效组的每一个元素即可。依次输入arrav(0) array(1) array(2)并按[Enter]键，分别得到
结果python、c和rust.

val array=Array("java","scala","go")

array-Array("python","go","rust")

scala> array(0)="python"

scala> array(1)="rust"

scala> array(2)="c"

scala> val a=array

var array=Array("java","scala","go")

var array=Array("python","c","rust")

array=Array("python","c","rust")

var array=Array("java

array=Array("python","c","rust")

scala> array(0)
res5: String = python

scala> array(1)
res6: String = c

scala> array(2)
res7: String = rust

Scala的lazy变量

 Scala的数据类型

实践

val s='fhg

s.name

3.toDouble

3.tolong

1.2.toInt

scala的字符字面量

val s="hello scala

                                                               hello java"

val s="""hello scala

                                                                hello java"""

Scala的对齐方案1.书写；2.stripMargin

val s=""""hello scala
|hello java""".stripMargin

val s=""""hello scala
@hello java""".stripMargin

Scala的非数值类型

char charAt(int index)

in indexOf(int ch)

boolean matches(String regex)

String replaceAll(String regex,String replacement)

String[] split(String regex)

boolean startWith(String prefix)

Scala的字符串分隔符

"hello,word".split(",")

结果——res0: Array[String] = Array(hello,word)

Scala的字符串查找

Regex.findAllInt(String) 迭代器
Regex.findFristIn(String) 找到字符串String中第一个匹配正则表达式的值并返回，其返回值是一个Option对象。

new Regex(正则表达式)

Scala的字符串替换

val regex="""(\d\d\d\d)-(\d\d)-(\d\d)""".r

val result=regex.findAllIn("2015-03-20,1985-11-24,2019-1-2")

for(date<-result)println(date)

val result=regex.findFirstIn("2015-03-20,1985-11-24,2019-1-2")

Scala的字符串遍历

for循环/yield

for{x <- String } {do something} [yield x ]

foreach

String.foreach (c=> do something )

map

String.map (c=> do something )

实践

val name="scala"

for(x<-name)println(x)

name.foreach(x=>println(x))

name.map(x=>println(x))

将Scala字符串转化成大写

name.map(x=>x.toUpper)

val s=for(x<-name)yield x.toUpper

val sb=new StringBuilder()

name.foreach(x=>sb.append(x.toUpper))

println(sb)

字符串遍历：

提取字符串“123456”偶数部分，返回一个新字符串

val num="123456"
val s=for(i<-num if(i%2==0))yield i

判断身份证号是否是北京省份证

scala> val iden="110111198712100423"
iden: String = 110111198712100423

scala> val a=iden.startsWith("110111")
a: Boolean = true

scala> val a=iden.startsWith("110114")
a: Boolean = false

将字符串'123456'变成‘234567’

scala> val num1="123456"
num1: String = 123456

scala> val str=num1.map(x=>x+1)
str: scala.collection.immutable.IndexedSeq[Int] = Vector(50, 51, 52, 53, 54, 55)

scala> val str=num1.map(x=>x.toString().toInt+1)
str: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 3, 4, 5, 6, 7)

scala的字符串插值

1.scala和java的区别

（1）java的表达方式

java拼接字符串

（2）scala的表达方式

第一，定义符

第二，$

第三，表达式{},{a==b}

三种格式

s"his name is $name"

f"his name is $name"

raw"his name is $name"

例如：name=jason,age=10,weight=180

name is Jason,10 years old and weight is 180kg

name is Jason,10 years old and weight is 180.00kg

name is Jason,10 years old and weight is 180.00kg\n1000g

areyou 10?true/false(年龄是10岁就输出true,否则出false)

scala> val name="jason"
name: String = jason

scala> val age=10
age: Int = 10

scala> val weights=180
weights: Int = 180

scala> println(name+"is"+age+"years old and weights is"+weights+"kg")
jasonis10years old and weights is180kg

scala> println(name+" is "+age+" years old and weights is" +weights+ " kg ")
jason is 10 years old and weights is180 kg 

scala> println(s"name is $name,$age years old and weights is $weights kg")
name is jason,10 years old and weights is 180 kg

scala> println(f"name is $name,$age years old and weights is $weights kg")
name is jason,10 years old and weights is 180 kg

scala> println(raw"name is $name,$age years old and weights is $weights kg")
name is jason,10 years old and weights is 180 kg

scala> println(f"name is $name,$age years old and weights is $weights%.2f kg")
name is jason,10 years old and weights is 180.00 kg

scala> println(f"name is $name,$age years old and weights is $weights%.2f kg\n1000g")
name is jason,10 years old and weights is 180.00 kg
1000g
scala> println(f"name is $name,$age years old and weights is $weights%.2f kg\\n1000g")
name is jason,10 years old and weights is 180.00 kg\n1000g
scala> println(s"are you 10 ?${age==10}")
are you 10 ?true
 

scala> val input="hadoop01"
input: String = hadoop01

scala> val hostsList="host01.host02.hadoop01.hadoop010"
hostsList: String = host01.host02.hadoop01.hadoop010

scala> val hosts=hostsList.split(",")
hosts: Array[String] = Array(host01.host02.hadoop01.hadoop010)

scala> val hostnames=for(host<-hosts if(input.toUpperCase==host.toUpperCase)) yield host
hostnames: Array[String] = Array()

scala> if(hostnames.length>0) println(s"i find $input") else println(s"i unfind $input")
i unfind hadoop01

scala的算术运算符

位移

优先级

相等性

def pre(d1:Double,d2:Double,precision:Double)={
    if((d1-d2).abs<precision) true else false
    }

BigDecimal(0.3) == BigDecimal(0.1) + BigDecimal(0.2)
val a=0.3
val b=0.1+0.2
def compare(x:Double,y:Double,p:Double)={if((x-y).abs<p) true else false}
compare(a,b,0.00001)
compare(a,b,0.0000000000000000003)

随机

通过相同三步的验证结果我们得到前面的R为伪随机序列。

创建一个随机长度的集合

for(i<-1 to r.nextInt(6)) yield r.nextInt(30)

for(i<-1 to r.nextInt(11)) yield r.nextPrintableChar

for(i<-1 to 8) yield r.nextPrintableChar

idea

package scala
object HelloWorld {
    def main(args:Array[String]):Unit={
        println("Hello World")
    }
}

Scala的条件结构











object ClassifyPerson {
  def main(args: Array[String]): Unit = {
    val c =matchAge(65)
    println(c)
  }
  def matchAge(age: Int)={
    var classify=if(age<=12)
    {
      "童年"
    }
    else if (age>=12&&age<=30)
    {
      "青年"
    }
    else if (age>=30&&age<=40)
    {
      "中年"
    }
    else if (age>=40&&age<=50)
    {
      "壮年"
    }
    else
    {
      "老年"
    }
    classify
  }
}

Scala的循环结构while

var i=0
while (i<5){
  println(s"i=$i")
  i+=1
}

var i=1
do{
println(s"i=$i")
i+=1
}while(i<1)

Scala中的for语句

val fruits = List("apple","banana","orange","strawberry")
for (fruit <-fruits) {
println(fruit)
}

Scala中的卫语句的for循环

val fruits = List("apple","banana","orange","strawberry")
for (fruit <-fruits
if fruit.startsWith("b"))
{
println(fruit)
}

Scala中的带返回值语句的for循环

val fruits = List("apple","banana","orange","strawberry")
val upfruit=for(fruit <- fruits if fruit.startsWith("b"))yield
fruit.toUpperCase
println("upfruit =" +upfruit）

Scala类和构造器

package scala
class Pig {
  var name="peiqi"
  var age = 90
  val color="red"
  private val sex=true
  println(s"sex=${sex}")}
  object RunPig{
    def main(args:Array[String]):Unit = {
      val p1 = new Pig()
      println(s"name=${p1.name},age=${p1.age},color=${p1.color}")
      p1.age = 100
      println(s"name=${p1.name},age=${p1.age},color=${p1.color}")
      p1.age_$eq(88)
      println(s"name=${p1.name},age=${p1.age},color=${p1.color}")
    }
}

package scala
class Rational (val x:Int=10,var y:Int,z:Int=20)
  {def sum():Int={
    x+y+z}}
object RunRational {
  def main(args:Array[String]):Unit={
    val r=new Rational(1,2,3)
    println(s"sum1=${r.sum()}")
    val r1=new Rational(y=1)
    println(s"sum2=${r1.sum()}")
    val r2=new Rational(5,y=1,10)
    println(s"sum3=${r2.sum()}")
  }

}

package scala
class Register(val name:String,var tel:String,var psword:String,var email:String){
  var company=""
  var position=""
  println("enter into Register contruction")
  def this (name:String,tel:String,psword:String,email:String,company:String) {
    this (name,tel,psword,email)
    this.company=company
  }
  def this (name:String,tel:String,psword:String,email:String,company:String,postion:String) {
    this (name:String,tel:String,psword:String,email:String,company:String)
  }
  override def toString = s"Register($company,$position,$name,$tel,$psword,$email)"
}
object RunRegister {
  def main(args: Array[String]): Unit = {
    var r= new Register(
      "xiaoxin","13301922222","123","abc@163.com"
    )
    println(r.toString)
    var r1= new Register(
      "xiaoxin","13301922222","124","abc@163.com","beijingal"
    )
    println(r1.toString)
    var r2= new Register(
      "xiaoxin","13301922222","123","abc@163.com","beijingal","manager"
    )
    println(r2.toString)
  }

}

package scala
class Car(val producerName: String,val productType: String,val carYear: Int,var carNum: String)
  {def this (producerName: String,productType: String){
    this (producerName,productType, -1,"空字符串")
  }
    def this(producerName: String,productType:String, carYear:Int){
      this (producerName,productType, carYear,"空字符串")
    }
    def this (producerName: String,productType:String,carNum: String) {
      this(producerName,productType,-1,carNum)
    }
    override def toString = s"Car($producerName,$productType,$carYear,$carNum)"
  }
object Car {
  def main(args: Array[String]): Unit = {
    val car1=new Car("audi","Q5",2008,"888888")
    val car2=new Car("auti","A6",2008)
    val car3=new Car("auti","A6",2008)
    val car4=new Car("auti","Q3","666666")
    println(s"car1=$car1")
    println(s"car2=$car2")
    println(s"car3=$car3")
    println(s"car4=$car4")
  }

}

Scala的伴生类和对象

package scala

object Single {
  var name="scala single"
  def printName()={
    println(s"name=$name")
  }
  def main(args:Array[String]):Unit={
    Single.printName()
  }

}

package scala

object Student {
  private val secrect1="i am secrect1 ******"
  def accessCompanionClass(s:Student)={
    print(s"access Companion Class private field =${s.secrect2}")
  }

}
class Student{
  private val secrect2="i am secrect2 ******"
  def accessCompanionObject() = {
    println(s"access Companion Object private field = ${Student.secrect1}")
  }
}
object Run1 {
  //extra class/object access student class field
  //Student.secrect1
  //object access Companion Class private field
  def main(args: Array[String]): Unit = {
    //object access Companion Class private field
    //student.accessCompanionClass (new student())
    //Class access Companion object private field
    new Student().accessCompanionObject()
  }
}

package scala
class Person{
  var name = "person"
  println("enter into person construction")}
object Person {
  println("enter into person construction")
  def apply(): Person = new Person()
  def apply(name: String):Person={
    var p =new Person()
    p.name=name
    p
  }
}
object RunPerson{
  def main(args: Array[String]): Unit = {
    /**
     * 1.new
     * new Person
     * 2.object
     * Person
     * 3.apply
     * 1.companion class and object
     * 2.overwrite apply on companion object
     * 3.apply return Person object
     */
    val p1 = Person("apply person")
    println(s"create object by apply p1=$p1")
    println(s"create object by apply p1=${p1.name}")
    val p2 = Person.apply("apply person")
    println(s"create object by qpply p2=$p2")
    println(s"create object by apply p2=${p2.name}")
  }
}

package scala

object RunJudgeObject {
  def main(args: Array[String]): Unit = {
    val p1=new Person2()
    val p2=new Person2()
    val s=new Student2()
    val t=new Teacher2()
    //1.getclass
    println(s"p1==p2 ? ${p1.getClass==p2.getClass}")
    println(s"p1==p1 ? ${p1.getClass==p1.getClass}")
    println(s"p1==s ? ${p1.getClass==s.getClass}")
    println(s"s==t ? ${p1.getClass==t.getClass}")
    println(s"p1=${p1.getClass},p2=${p2.getClass},s=${s.getClass},t=${t.getClass}")
    //isinstanceof
    println(s"p1 isInstanceOF person2 ? ${p1.isInstanceOf[Person2]}")
    println(s"p2 isInstanceOF person2 ? ${p1.isInstanceOf[Person2]}")
    println(s"s isInstanceOF person2 ? ${p1.isInstanceOf[Person2]}")
    println(s"t isInstanceOF person2 ? ${p1.isInstanceOf[Person2]}")
    println(s"s isInstanceOF person2 ? ${p1.isInstanceOf[Person2]}")
  }}
class Person2{var name="person1"}
class Student2 extends Person2{
}
class Teacher2 extends Person2{
}

Scala的单列对象

Scala的对象创建

Scala的所属类

Scala对象相等性的判断

SCALA的特殊类型

期末考点

1. 变量定义格式是什么？可变不可变变量定义格式
val/var 变量名 :数据类型 = 初始值 val不可变

2. 一般的代码段输出，比如定义变量利用条件语句看输出结果
    val a:String="aaaa"
    println(a);

3. For 循环如何遍历集合元素
 val abc = Array[String]("蔡徐坤","陈立农","范丞丞","黄明昊")
    for(i <- abc)
      println(i)

4. 不可变字符串如何定义？
val aaa:String=""

5. 在 scala 中如何定义函数？
def name(a:Int,b;Int):Int ={
c=a+b
return c
}

6. 如何定义数组？格式是什么？
    val a=Array[Int](1,2,3,4,5)
    for(i <-a)
      println(i)

7. Scala 中合法的标识符
不能以数字开头
首字母为字母，后续字符为字母数字$与_
受自负为操作符后续字符也需操作符（+-*/）反编译
反引号包括的字符串即使是关键字也可以使用

8. 如何在 scala 中中断循环跳到下一次循环？
import util.control.Breaks 导入包
val a=Array[Int](1,2,3,4,5)
    val b=new Breaks;
    for(i <-a){
      b.breakable{
        if(i==4) b.break()
        print(i)
      }
      }
  }

9. scala 程序的编译和运行顺序？
main为入口
10. 创建一个类时使用哪个关键字？
class
11. scala 程序的编译指令
scalac
12. scala 程序的运行指令
scala
13. 针对编译完成的 class 文件，直接用记事本文件打开，出现乱码现象，因此如何才能将
class 文件内容编程我们能看懂的代码？
scalap
14. Scala 中如何创建一个类的实例对象？
class
15. 在 Scala 中，如何定义一个抽象类？
abstract class
16. 在 Scala 中，查看程序当前运行路径的指令是？
import java.io.File 导入包
    val a = new File("").getAbsolutePath
    println(a)
17. 关于 lazy 变量描述
lazy变量也叫惰性变量 只有在使用时才会被初始化
18. 直接实现截取后四位功能的函数
19. Scala 的关键特性（最少列举三个）
面向对象
函数式编程
静态类型
可扩展
20. Scala 主要包括哪些循环语句？并阐述 while 循环和 do while 循环的区别
for，while，do while
21. 求和功能：-1+2-3+4-5+6-7+8...100
    var a=0;
    var sum=0;
    for(a<-1 to 100)
      {
        if(a%2!=0)
          sum=sum+(-a)
        else
          sum=sum+a
        println(sum)
      }
22. 用户登录功能，输入用户名和密码要求最多输入次数不超过 3 次

23. 针对以下 pig 类的定义，在类的实例化及属性修改的过程中 p1.color=“blue”报错，请重新书写以下类定义、类的实例化及类属性修改的代码，使其能实现 p1.color=“blue”修改的效果。