Scala作业（3）：类/包和引入

类

1、编写一个Time类，加入只读属性hours和minutes，和一个检查某一时刻是否早于另一时刻的方法before(other:Time):Boolean。Time对象应该以new Time(hrs,min)方式构建。

以下是一个示例的 Time 类的实现，包括只读属性 hours 和 minutes，以及用于比较时间的方法 before：

class Time(val hours: Int, val minutes: Int) {
  def before(other: Time): Boolean = {
    if (hours < other.hours) {
      true
    } else if (hours == other.hours && minutes < other.minutes) {
      true
    } else {
      false
    }
  }

  override def toString: String = f"$hours%02d:$minutes%02d"
}

// 测试
val t1 = new Time(9, 30)
val t2 = new Time(10, 15)

println(t1)  // 输出: 09:30
println(t2)  // 输出: 10:15

println(t1.before(t2))  // 输出: true
println(t2.before(t1))  // 输出: false

在上面的代码中，我们定义了一个名为 Time 的类，它具有只读属性 hours 和 minutes，它们分别用于存储小时和分钟。我们还实现了一个 before 方法，它接受另一个 Time 对象作为参数，并返回一个布尔值，指示当前时间是否早于给定的时间。

在 before 方法中，我们首先比较小时部分 hours，如果当前时间的小时部分小于给定时间的小时部分，则返回 true。如果小时部分相等，则比较分钟部分 minutes，如果当前时间的分钟部分小于给定时间的分钟部分，则返回 true。否则，返回 false。

我们还重写了 toString 方法，用于以字符串形式表示时间对象。

最后，我们进行了一些测试，创建了两个 Time 对象 t1 和 t2，并打印了它们的字符串表示形式，以及调用了 before 方法进行比较。

运行上述代码将输出以下结果：

09:30
10:15
true
false

这样，你就成功地编写了一个包含只读属性和比较方法的 Time 类。

2、创建一个Student类，加入可读写的JavaBeans属性name(类型为String)和id(类型为Long)。有哪些方法被生产？(用javap查看。)你可以在Scala中调用JavaBeans的getter和setter方法吗？

在 Scala 中，我们可以创建一个 Student 类，具有可读写的 JavaBeans 属性 name 和 id。编译后，可以使用 javap 命令查看生成的字节码文件，以了解生成的方法。

以下是示例的 Student 类的实现：

class Student {
  private var _name: String = ""
  private var _id: Long = 0L

  def getName: String = _name
  def setName(name: String): Unit = _name = name

  def getId: Long = _id
  def setId(id: Long): Unit = _id = id
}

编译 Student 类后，可以使用 javap 命令查看生成的字节码文件。打开终端并执行以下命令：

javap -private Student

这将显示生成的方法列表，其中包括 getter 和 setter 方法。例如，对于 name 属性，生成的方法包括 getName 和 setName。对于 id 属性，生成的方法包括 getId 和 setId。

在 Scala 中，我们可以直接调用 JavaBeans 的 getter 和 setter 方法。例如：

val student = new Student()
student.setName("John")
println(student.getName)  // 输出: John

student.setId(12345)
println(student.getId)  // 输出: 12345

在上面的示例中，我们创建了一个 Student 对象 student，并使用 setName 方法设置 name 属性的值为 “John”。然后，我们使用 getName 方法获取 name 属性的值并打印出来。类似地，我们使用 setId 方法设置 id 属性的值为 12345，并使用 getId 方法获取 id 属性的值并打印出来。

因此，我们可以在 Scala 中调用 JavaBeans 的 getter 和 setter 方法来访问可读写的属性。

包和引入

1、练习使用包的各种声明方式，并查看他们的不同

在 Scala 中，我们可以使用不同的方式声明和引用包。以下是几种常见的包声明和引用方式以及它们的区别：

1. 使用简单的包名引用：

import mypackage.MyClass

这种方式只引用了指定包中的一个类，可以直接使用该类名进行访问。

2. 使用包名引用所有成员：

import mypackage._

这种方式引用了指定包中的所有成员，包括类、对象、方法等。可以直接使用成员的名称进行访问。

3. 使用特定成员引用：

import mypackage.{MyClass, myFunction}

这种方式只引用了指定包中的特定成员，可以通过它们的名称直接访问。

4. 使用重命名引用：

import mypackage.{MyClass => RenamedClass}

这种方式引用了指定包中的一个类，并将其重命名为 RenamedClass。可以使用新的名称进行访问。

这些方式的区别在于引用的范围和可见性。简单的包名引用只引用一个特定的类，其他成员需要使用完整的包名进行访问。引用所有成员可以方便地访问包中的所有成员，但可能会导入不需要的成员。使用特定成员引用可以只引用需要的成员，减少了不必要的导入。重命名引用可以将成员重命名为其他名称，以便更方便地使用。

需要注意的是，不同的引用方式可能会导致名称冲突或歧义，因此需要谨慎使用。

请根据你的实际需要选择适合的包引用方式，并根据实际情况查看它们的不同效果。

2、编写一段程序,将Java哈希映射中的所有元素拷贝到Scala哈希映射。用引入语句重命名这两个类。

在 Scala 中，可以使用引入语句重命名类来简化类的使用。下面是一个示例程序，将 Java 哈希映射中的所有元素拷贝到 Scala 哈希映射，并使用引入语句重命名这两个类：

import java.util.{HashMap => JavaHashMap}
import scala.collection.mutable.{HashMap => ScalaHashMap}

object HashMapCopyExample {
  def main(args: Array[String]): Unit = {
    // 创建一个 Java 哈希映射并添加元素
    val javaMap = new JavaHashMap[Int, String]()
    javaMap.put(1, "One")
    javaMap.put(2, "Two")
    javaMap.put(3, "Three")

    // 创建一个 Scala 哈希映射
    val scalaMap = new ScalaHashMap[Int, String]()

    // 将 Java 哈希映射的元素拷贝到 Scala 哈希映射
    val iterator = javaMap.entrySet().iterator()
    while (iterator.hasNext) {
      val entry = iterator.next()
      scalaMap.put(entry.getKey, entry.getValue)
    }

    // 打印 Scala 哈希映射中的元素
    scalaMap.foreach { case (key, value) =>
      println(s"Key: $key, Value: $value")
    }
  }
}

在上面的示例中，我们使用 import 语句重命名了 java.util.HashMap 为 JavaHashMap，以及 scala.collection.mutable.HashMap 为 ScalaHashMap。这样就可以使用简化的名称来引用这两个类。

我们创建了一个 Java 哈希映射 javaMap 并向其中添加一些元素。然后，我们创建了一个空的 Scala 哈希映射 scalaMap。接下来，我们通过迭代 Java 哈希映射的条目，并将每个条目的键值对拷贝到 Scala 哈希映射中。

最后，我们遍历 Scala 哈希映射，并打印出其中的元素。

运行上述代码将输出以下结果：

Key: 1, Value: One
Key: 2, Value: Two
Key: 3, Value: Three

这样，我们成功地将 Java 哈希映射中的元素拷贝到了 Scala 哈希映射，并使用了引入语句重命名这两个类，使代码更加简洁。