私有字段和方法

上一个版本的Rational类里，我们只是分别用n初始化了numer，用d初始化了denom。结果，Rational的分子和分母可能比它所需要的要大。例如分数 ，可以更约简化为相同的最简形式， ，但Rational的主构造器当前并不做这个工作：

51CTO编辑推荐：Scala编程语言专题

scala> new Rational(66, 42)  
res15: Rational = 66/42 

class Rational(n: Int, d: Int) {  
 require(d != 0)  
 private val g = gcd(n.abs, d.abs)  
 val numer = n / g  
 val denom = d / g  
 def this(n: Int) = this(n, 1)  
 def add(that: Rational): Rational =  
  new Rational(  
   numer * that.denom + that.numer * denom,  
   denom * that.denom  
  )  
 override def toString = numer+"/"+denom  
 private def gcd(a: Int, b: Int): Int =  
  if (b == 0) a else gcd(b, a % b)  
}  

这个版本的Rational里，我们添加了私有字段，g，并修改了numer和denom的初始化器（初始化器：initializer是初始化变量，例如初始化numer的“n / g”，的代码）。因为g是私有的，它只能在类的主体之内，而不能在外部被访问。我们还添加了一个私有方法，gcd，用来计算传入的两个Int的***公约数。比方说，gcd(12, 8)是4。正如你在4.1节中看到的，想让一个字段或方法私有化你只要把private关键字放在定义的前面。私有的“助手方法”gcd的目的是把类的其它部分，这里是主构造器，需要的代码分离出来。为了确保g始终是正的，我们传入n和d的绝对值，调用abs即可获得任意整数的绝对值。

Scala编译器将把Rational的三个字段的初始化代码依照它们在源代码中出现的次序放入主构造器。所以g的初始化代码，gcd(n.abs, d.abs)，将在另外两个之前执行，因为它在源文件中出现得最早。g将被初始化为类参数，n和d，的绝对值的***公约数。然后再被用于numer和denom的初始化。通过把n和d整除它们的***公约数，g，每个Rational都将被构造成它的最简形式：

scala> new Rational(66, 42)  
res24: Rational = 11/7 

Rational加法的当前实现仅就完成功能来讲是没问题的，但它可以做得更好用。你或许会问你自己为什么对于整数或浮点数你可以写成：

x + y 

x.add(y) 

x add y 

***步是用通常的数学的符号替换add方法。这可以直接做到，因为Scala里+是合法的标识符。我们可以用+定义方法名。既然已经到这儿了，你可以同样实现一个*方法以实现乘法，结果展示在代码6.4中：

class Rational(n: Int, d: Int) {  
 require(d != 0)  
 private val g = gcd(n.abs, d.abs)  
 val numer = n / g  
 val denom = d / g  
 def this(n: Int) = this(n, 1)  
 def +(that: Rational): Rational =  
  new Rational(  
   numer * that.denom + that.numer * denom,  
   denom * that.denom  
  )  
 def *(that: Rational): Rational =  
  new Rational(numer * that.numer, denom * that.denom)  
 override def toString = numer+"/"+denom  
 private def gcd(a: Int, b: Int): Int =  
  if (b == 0) a else gcd(b, a % b)  
}  

有了这种方式定义的Rational类，你现在可以这么写了：

scala> val x = new Rational(1, 2)  
x: Rational = 1/2 
scala> val y = new Rational(2, 3)  
y: Rational = 2/3 
scala> x + y  
res32: Rational = 7/6 

scala> x.+(y)  
res33: Rational = 7/6 

另外一件要提的是基于5.8节中提到的Scala的操作符优先级规则，Rational里面的*方法要比+方法绑定得更结实。或者说，Rational涉及到+和*操作的表达式会按照预期的方式那样表现。例如，x + x * y会当作x + (x * y)而不是(x + x) * y：

scala> x + x * y  
res34: Rational = 5/6 
scala> (x + x) * y  
res35: Rational = 2/3 
scala> x + (x * y)  
res36: Rational = 5/6 

【相关阅读】

1. Scala的从构造器：主构造器之外的构造器
2. 在Scala中检查先决条件、添加字段和自指向
3. Scala Rational对象的toString方法
4. 学习Scala中的Rational类：分数的模型化
5. Scala中的富包装器：富操作和富类列表