02.类与对象.md

02 类与对象

1 使用 require 方法解决参数检查

class Rational(n: Int, d: Int) {
//  println(s"created ${n}/${d}")
  require(d != 0)
  override def toString: String = n + "/"  + d
}

...

def main(args: Array[String]): Unit = {
  val y = new Rational(2, 0)
  println(y)
}

抛出异常

java.lang.IllegalArgumentException

2 构造参数扩展成成员变量

class Rational(n: Int, d: Int) {
  //  println(s"created ${n}/${d}")
  require(d != 0)

  override def toString: String = n + "/" + d

  //重新赋值并声明成成员变量
  val number = n

  val denom = d

  def add(that: Rational): Rational = {
    new Rational(
      number * that.denom + that.number * denom,
      denom * that.denom)
  }

}


object RTest {

  def main(args: Array[String]): Unit = {
    val x = new Rational(1, 2)
    val y = new Rational(1, 3)
    println(x add y)
  }
}

3 this 的使用

// 访问属性时，this 可省略
def lessThan(that: Rational): Boolean = {
  this.number * that.denom < denom * that.number
}

//返回自身时，使用 this
def max(that: Rational): Rational = {
  if(lessThan(that)) that else this
}

4 辅助构造函数

除主构造函数之外的构造函数都是辅助构造函数，所有辅助构造函数的名称都为this，其第一个语句都为调用其它构造函数（可以是主构造函数或其它辅助构造函数，最终会调用主构造函数） 由于上述条件限制，使得每个构造函数最终都会调用主构造函数，从而使得主构造函数成为创建类单一入口点，此外在 scala 中只有主构造函数可以调用基类的构造函数，这些限制可以保证一致性。

class Rational(n: Int, d: Int) {

  // 辅助构造函数, 定义整数有理数
  def this(n:Int) = this(n,1)

  ...

5 私有变量及私有方法

class Rational(n: Int, d: Int) {
  require(d != 0)

  // 初始化时，被引用的成员变量需定义在前面
  private val g = gcd(n.abs, d.abs)

  val number: Int = n / g

  val denom: Int = d / g

  override def toString: String = number + "/" + denom

  def add(that: Rational): Rational = {
    new Rational(
      number * that.denom + denom * that.number,
      denom * that.denom
    )
  }

  /**
   * 回溯函数必须定义返回值
   */
  @scala.annotation.tailrec
  private def gcd(a: Int, b: Int): Int = {
    if (b == 0) a else gcd(b, a % b)
  }
  
}

6 标志符

如果使用关键字作为标志符，需要加重音符号，比如 Thread.`yield`()

对于 +、++、:::、<、 ?>、 :-> 之类的符号，scala 内部实现时会使用转义的标志符。 如 :-> 使用 $colon$minus$greater 来表示这个符号。在 Java 代码中访问 :-> 方法，需要使用 scala 的内部名称 $colon$minus$greater 。

如果你需要定义一元运算符，你可以使用 +、-、! 和 ~ 四个符号作为前缀操作符。

class Rational(n:Int, d:Int)
{
  // ... as before ...
 
  //求倒数，分子与分母颠倒
  def unary_~ : Rational =
    new Rational(denom, numer)
}

7 隐式转换

val x = new Rational(66, 42)
val y = new Rational(2, 3)

//定义隐式转换
implicit def intToRational(x:Int): Rational = new Rational(x)

println(5 + x)
println(x + 4)

8 枚举

可以选择继承 Enumeration，也可以使用 case class