1. 第1题
编写类：
class Counter {
private var value = Int.MaxValue - 5
def increment() {
if (value < Int.MaxValue)
value += 1
else println("Reaching the maximum of Int!")
}
def current = value
}
测试代码：
var count = new Counter
for (i <- 0 until 10) {
count.increment()
println(s"Current value is ${count.current}")
}
2. 第二题
编写类：
class BankAccount {
private var balance: Double = 0 //私有字段，只有一个getter方法
def deposit(balance: Double): Unit = {
this.balance += balance
}
def withDraw(balance: Double): Unit = {
if (balance <= this.balance) {
this.balance -= balance
} else {
println(f"Current balance = ${this.balance}, The withdraw amount is beyond balance!")
}
}
def currentBalance = balance
}
测试代码：
var account = new BankAccount
print(account.currentBalance)
account.deposit(1000)
account.deposit(20000)
print(account.currentBalance)
account.withDraw(40000)
account.withDraw(15000)
print(account.currentBalance)
3. 第三题
编写类：
class Time(val hrs: Int, val min: Int) { //使用主构造器，字段声明为val，只带getter属性，表示只读
// 主构造器会执行类定义中的所有语句，用此特性检验输入参数的合法性
if (hrs < 0 || hrs > 23) throw new Exception("The hrs para is beyond the limit from 0 to 23!")
if (min < 0 || min > 59) throw new Exception("The min para is beyond the limit from 0 to 59!")
def before(other: Time) : Boolean = {
hrs < other.hrs || (hrs == other.hrs && min < other.min)
}
}
测试代码：
val time1 = new Time(8, 56)
time1.hrs
time1.min
time1.hrs = 12 //尝试调用getter属性，报错，因为是只读的
var time2 = new Time(12, 38)
time1.before(time2)
var time3 = new Time(12, 20)
time2.before(time3)
var time4 = new Time(24, 10)
var time5 = new Time(23, 60)
4. 第四题
编写代码：
class Time1(hrs: Int, min: Int) { //使用主构造器，两个字段未带val/var，表示对象私有，无getter和setter
// 主构造器会执行类定义中的所有语句，用此特性检验输入参数的合法性
if (hrs < 0 || hrs > 23) throw new Exception("The hrs para is beyond the limit from 0 to 23!")
if (min < 0 || min > 59) throw new Exception("The min para is beyond the limit from 0 to 59!")
val mins = hrs * 60 + min
def getHrs = mins / 60
def getMin = mins % 60
def before(other: Time1) : Boolean = {
mins < other.mins
}
}
测试代码：
val time11 = new Time1(8, 56)
time11.getHrs
time11.getMin
var time12 = new Time1(12, 38)
time11.before(time12)
var time13 = new Time1(12, 20)
time12.before(time13)
var time14 = new Time1(24, 10)
var time15 = new Time1(23, 60)
5. 第五题
编写类文件 Students.scala：
import scala.beans.BeanProperty
class Students {
@BeanProperty var name: String = _
@BeanProperty var id: Long = _
}
打开命令行终端，cd到Students.scala所在目录，然后执行：
scalac Students.scala
javap -private Students
生成了9个方法，java风格setter和getter共4个，scala风格的getter和setter共4个，再加一个主构造器。如下图所示。
image.png
测试代码：
var stu = new Students
stu.name = "John"
stu.id = 1000000001
stu.setName("Alice")
stu.getName
6. 第六题
代码：
class Person(var age: Int) {
if (age < 0) age = 0
}
7. 第七题
代码（因为对象不需要访问该参数，所以使用普通参数，使其对象私有）：
class Person2(name: String) {
def firstName = name.split(" ")(1)
def lastName = name.split(" ")(0)
}
测试代码：class
var per = new Person2("John Xu")
per.firstName
per.lastName
8. 第八题
8.1 法1
代码：
class Car(val manufacture: String, val typeName: String) { //主构造器，通过val设置两个字段（制造商、型号名称）只读
//设置另外两个字段（型号年份、车牌号）的默认值
private var typeYear = -1 //通过 private 和 getter 设置只读
var number = ""
def this(manufacture: String, typeName: String, typeYear: Int) {
this(manufacture, typeName)
this.typeYear = typeYear
}
def this(manufacture: String, typeName: String, number: String) {
this(manufacture, typeName)
this.number = number
}
def this(manufacture: String, typeName: String, typeYear: Int, number: String) {
this(manufacture, typeName, typeYear)
this.number = number
}
def getTypeYear = typeYear
def description = manufacture + " | " + typeName + " | " + typeYear + " | " + number
}
测试代码：
var car1 = new Car("BYD", "Qin")
print("car1: " + car1.description)
var car2 = new Car("BYD", "Qin", 2018)
print("car2: " + car2.description)
car2.typeName //只读
car2.number //读
car2.number = "K3W86J" //写
car2.manufacture //只读
car2.getTypeYear //只读
var car3 = new Car("BYD", "Qin", "Q2W80")
print("car3: " + car3.description)
var car4 = new Car("BYD", "Qin", 2017, "B88K0")
print("car4: " + car4.description)
8.2 法2 (更scala风格、代码更精简)
代码：
class Car2(val manufacture: String, val typeName: String, val typeYear: Int, var number: String) {
def this(manufacture: String, typeName: String, typeYear: Int) {
this(manufacture, typeName, typeYear, "")
}
def this(manufacture: String, typeName: String, number: String) {
this(manufacture, typeName, -1, number)
}
def this(manufacture: String, typeName: String) {
this(manufacture, typeName, -1, "")
}
def description = manufacture + " | " + typeName + " | " + typeYear + " | " + number
}
测试代码：
var car21 = new Car2("BYD", "Qin")
print("car21: " + car21.description)
var car22 = new Car2("BYD", "Qin", 2018)
print("car22: " + car2.description)
car22.typeName //只读
car22.number //读
car22.number = "K3W86J" //写
car22.manufacture //只读
car22.typeYear //只读
var car23 = new Car2("BYD", "Qin", "Q2W80")
print("car23: " + car23.description)
var car24 = new Car2("BYD", "Qin", 2017, "B88K0")
print("car24: " + car24.description)
10. 第十题
10.1 自定义主构造器
题中代码：
class Employee(val name: String, var salary: Double) { // 自定义主构造器，name只读，salary可读写
def this() { this("John Q. Public", 0.0)}
}
测试代码：
var em = new Employee()
em.name
em.salary
em.salary = 20000
10.2 字段显示定义，使用默认主构造器:
代码：
class Employee2 {
//字段显示定义
private var name: String = "John Q. Public"
var salary = 0.0
def this(name: String, salary: Double) {
this() //默认主构造器
this.name = name
this.salary = salary
}
//显示定义只读字段时，除了声明字段为private var，还需要自定义getter
def getName = this.name
}
测试代码：
var em2 = new Employee2()
em2.getName
em2.salary
em2.salary = 30000
10.3 总结
更倾向于第一种，将只读字段放进自定义主构造器中，让代码更精简
