1、 - 1 - 来自： think in java （ 3） 外文原文 The busy Java developers guide to Scala: Class action It makes sense for Java developers to use objects as a first point of reference for understanding Scala. In this second installment of The busy Java developers guide to Scala series, Ted Neward follows a basic p
2、remise of language measurement: that the power of a language can be measured in direct relation to its ability to integrate new facilities - in this case, support for complex numbers. Along the way youll see some interesting tidbits related to class definitions and usage in Scala. In last months art
3、icle , you saw just a touch of Scalas syntax, the bare minimum necessary to run a Scala program and observe some of its simpler features. The Hello World and Timer examples from that article let you see Scalas Application class, its syntax for method definitions and anonymous functions, just a glimp
4、se of an Array, and a bit on type-inferencing. Scala has a great deal more to offer, so this article investigates the intricacies of Scala coding. Scalas functional programming features are compelling, but theyre not the only reason Java developers should be interested in the language. In fact, Scal
5、a blends functional concepts and object orientation. In order to let the Java-cum-Scala programmer feel more at home, it makes sense to look at Scalas object features and see how they map over to Java linguistically. Bear in mind that there isnt a direct mapping for some of these features, or in som
6、e cases, the mapping is more of an analog than a direct parallel. But where the distinction is important, Ill point it out. Scala has class(es), too Rather than embark on a lengthy and abstract discussion of the class features that Scala supports, lets look at a definition for a class that might be
7、used to bring rational number support to the Scala platform (largely swiped from Scala By Example - see Resources): Listing 1. rational.scala class Rational(n:Int, d:Int) private def gcd(x:Int, y:Int): Int = if (x=0) y else if (x0) gcd(-x, y) else if (y0) -gcd(x, -y) - 2 - else gcd(y%x, x) private v
8、al g = gcd(n,d) val numer:Int = n/g val denom:Int = d/g def +(that:Rational) = new Rational(numer*that.denom + that.numer*denom, denom * that.denom) def -(that:Rational) = new Rational(numer * that.denom - that.numer * denom, denom * that.denom) def *(that:Rational) = new Rational(numer * that.numer
9、, denom * that.denom) def /(that:Rational) = new Rational(numer * that.denom, denom * that.numer) override def toString() = Rational: + numer + / + denom + While the overall structure of Listing 1 is lexically similar to what youve seen in Java code over the last decade, some new elements clearly ar
10、e at work here. Before picking this definition apart, take a look at the code to exercise the new Rational class: Listing 2. RunRational class Rational(n:Int, d:Int) / . as before object RunRational extends Application val r1 = new Rational(1, 3) val r2 = new Rational(2, 5) val r3 = r1 - r2 val r4 =
11、 r1 + r2 Console.println(r1 = + r1) Console.println(r2 = + r2) Console.println(r3 = r1 - r2 = + r3) - 3 - Console.println(r4 = r1 + r2 = + r4) What you see in Listing 2 isnt terribly exciting: I create a couple of rational numbers, create two more Rationals as the addition and subtraction of the fir
12、st two, and echo everything to the console. (Note that Console.println() comes from the Scala core library, living in scala.*, and is implicitly imported into every Scala program, just as java.lang is in Java programming.) How many ways shall I construct thee? Now look again at the first line in the
13、 Rational class definition: Listing 3. Scalas default constructor class Rational(n:Int, d:Int) / . Although you might think youre looking at some kind of generics-like syntax in Listing 3, its actually the default and preferred constructor for the Rational class: n and d are simply the parameters to
14、 that constructor. Scalas preference for a single constructor makes a certain kind of sense - most classes end up having a single constructor or a collection of constructors that all chain through a single constructor as a convenience. If you wanted to, you could define more constructors on a Ration
15、al like so: Listing 4. A chain of constructors class Rational(n:Int, d:Int) def this(d:Int) = this(0, d) Note that Scalas constructor chain does the usual Java-constructor-chaining thing by calling into the preferred constructor (the Int,Int version). Details, (implementation) details. When working
16、with rational numbers, it helps to perform a bit of numerical legerdemain: namely that of finding a common denominator to make certain operations easier. If you want to add 1-over-2 (also known as one-half) to 2-over-4 (also known as two-fourths), the Rational class should be smart enough to realize that 2-over-4 is the same as 1-over-2, and convert it accordingly before adding the two together.
