《快学Scala》习题详解 第8章 继承

1 扩展如下的BankAccount类，新类CheckingAccount对每次存款和取款都收取1美元的手续费

class BankAccount(initialBalance:Double){ 
private var balance = initialBalance 
def deposit(amount:Double) = { balance += amount; balance} 
def withdraw(amount:Double) = {balance -= amount; balance} 
}
//重写
class BankAccount(initialBalance: Double) {
  private var balance = initialBalance
  def deposit(amount: Double) = { balance += amount; balance }
  def withdraw(amount: Double) = { balance -= amount; balance }
}
class CheckingAccount(var balance: Double) extends BankAccount(balance) {
  override def deposit(amount: Double) = { super.deposit(amount) - 1 }
  override def withdraw(amount: Double) = { super.withdraw(amount) - 1 }
}

2 扩展前一个练习的BankAccount类，新类SavingsAccount每个月都有利息产生(earnMonthlyInterest方法被调用)，并且有每月三次免手续费的存款或取款。在earnMonthlyInterest方法中重置交易计数。

class SavingsAccount(var balance: Double) extends BankAccount(balance) {
  var count = 3
  override def deposit(amount: Double) = {
    if (count > 1) {
      count -= 1
      super.deposit(amount)
    } else super.deposit(amount) - 1
  }
  override def withdraw(amount: Double) = {
    if (count > 1) {
      count -= 1
      super.withdraw(amount)
    } else super.withdraw(amount) - 1
  }
  def earnMonthlyInterest() {
    //月初，交易次数，变为3，并产生利息
    count = 3
    balance *= 1.02
  }
}

3 翻开你喜欢的Java或C++教科书，一定会找到用来讲解继承层级的实例，可能是员工，宠物，图形或类似的东西。用Scala来实现这个示例。

abstract class Animal(val name: String) {
  def eat
}
class Dog(name: String, var age: Int) extends Animal(name) {
  def eat = println(1)
  def bark = println(3)
}
class Cat(name: String, var age: Int) extends Animal(name) {
  def eat = println(2)
}

4 定义一个抽象类Item,加入方法price和description。SimpleItem是一个在构造器中给出价格和描述的物件。利用val可以重写def这个事实。Bundle是一个可以包含其他物件的物件。其价格是打包中所有物件的价格之和。同时提供一个将物件添加到打包当中的机制，以及一个适合的description方法

abstract class Item(val SimpleItem: Tuple2[String, Int]) {
  var Bundle: ArrayBuffer[Tuple2[String, Int]] = _
  def price: Int 
  def description: String
  def getPrice() {
    println(Bundle.map { x => x._2 }.sum)
  }
  def getDes() {
    println(Bundle.map { x => x._1 }.map { x => println(x + " ") })
  }
}
//使用val复写def，A将获得一个price字段，overrideItem的price为getter
class A(SimpleItem: Tuple2[String, Int], override val price: Int, override val description: String) extends Item(SimpleItem) {
}
// 扩展Item时，必须包含Item主构造器内的内容，并且可以更名
class B(a: Tuple2[String, Int]) extends Item(a) {
  def price = 3
  def description = ""
}

5 设计一个Point类，其x和y坐标可以通过构造器提供。提供一个子类LabeledPoint，其构造器接受一个标签值和x,y坐标,比如:new LabeledPoint(“Black Thursday”,1929,230.07)

class point(val x: Int, var y: Int) {}
//扩展父类时，x,y不能用val,var修饰，会被认为override
//override时，需要同名，val可被val复写，var只有在抽象时被var复写
// 无参的def，可被val/var/def复写
class LabledPoint(var name: String, override val x: Int, y: Int) extends point(x, y) {
}

6 定义一个抽象类Shape，一个抽象方法centerPoint，以及该抽象类的子类Rectangle和Circle。为子类提供合适的构造器，并重写centerPoint方法

abstract class Shape {
  def centerPoint: String
}
class Rectangle extends Shape {
  def centerPoint = { "" }
}
// 子类复写父类def时，父类必须指定返回类型
class Circle(override val centerPoint: String) extends Shape {
}

7 提供一个Square类，扩展自java.awt.Rectangle并且是三个构造器：一个以给定的端点和宽度构造正方形，一个以(0,0)为端点和给定的宽度构造正方形，一个以(0,0)为端点,0为宽度构造正方形

class Square(x: Int, y: Int, width: Int) extends java.awt.Rectangle {
  def this(width: Int) {
    this(0, 0, width)
  }
  def this() {
    this(0, 0, 0)
  }
}

8 编译8.6节中的Person和SecretAgent类并使用javap分析类文件。总共有多少name的getter方法？它们分别取什么值？(提示：可以使用-c和-private选项)

class Person(val name: String) {
  override def toString = getClass.getName + name
}

一个private 字段，getter方法，构造器，复写的toString方法

class Secret(code: String) extends Person(code) {
  override val name = "secret"
  override val toString = "???"
}

name被override
toString变成了带有getter的字段，print对象时，会自动使用toString的getter
code变成了普通方法参数（Secret类的方法没有使用到code）

9 在8.10节的Creature类中，将val range替换成一个def。如果你在Ant子类中也用def的话会有什么效果？如果在子类中使用val又会有什么效果？为什么？
使用def

class Creature {
  def range: Int = 10;
  val env: Array[Int] = new Array[Int](range)
}
class Ant extends Creature with App {
  override def range: Int = 2
}
object sfsdf extends App {
  val a = new Ant()
  println(a.env.size)
  // 输出2
}

Ant的env初始化时调用的是overide后的range()方法
range()方法返回2

使用val

class Creature {
  val range: Int = 10;
  val env: Array[Int] = new Array[Int](range)
}
class Ant extends Creature {
  override val range: Int = 2
}
object sfsdf extends App {
  val a = new Ant()
  println(a.env.size)
  //输出0
}

Creature反编译后：

Ant反编译后：

range在Creature中为方法
在Ant中被扩展为了字段，getter复写了父类的range()方法
与书中直接val情况一致：
Ant初始化构造器前，先初始化Creature构造器，构造时会调用Ant的range()方法(override后的)对
env进行赋值，此时Ant的range的未被赋值，因此为0

10 文件scala/collection/immutable/Stack.scala包含如下定义:
class Stack[A] protected (protected val elems: List[A])
请解释protected关键字的含义。(提示：回顾我们在第5章中关于私有构造器的讨论)

在Stack.scala中还真没找到这句话
Stack的字段elems，可被任何子类所访问，对于类所属包的其它成员不可见