Odersky M. Programming in Scala
Подождите немного. Документ загружается.
Section 10.14 Chapter 10 · Composition and Inheritance 231
object Element {
def elem(contents: Array[String]): Element =
new ArrayElement(contents)
def elem(chr: Char, width: Int, height: Int): Element =
new UniformElement(chr, width, height)
def elem(line: String): Element =
new LineElement(line)
}
Listing 10.10 · A factory object with factory methods.
singleton object, we will import Element.elem at the top of the source file.
In other words, instead of invoking the factory methods with Element.elem
inside class Element, we’ll import Element.elem so we can just call the
factory methods by their simple name, elem. Listing 10.11 shows what class
Element will look like after these changes.
In addition, given the factory methods, the subclasses ArrayElement,
LineElement and UniformElement could now be private, because they
need no longer be accessed directly by clients. In Scala, you can define
classes and singleton objects inside other classes and singleton objects. One
way to make the Element subclasses private, therefore, is to place them in-
side the Element singleton object and declare them private there. The classes
will still be accessible to the three elem factory methods, where they are
needed. Listing 10.12 shows how that will look.
10.14 Heighten and widen
We need one last enhancement. The version of Element shown in List-
ing 10.11 is not quite sufficient, because it does not allow clients to place el-
ements of different widths on top of each other, or place elements of different
heights beside each other. For example, evaluating the following expression
would not work correctly, because the second line in the combined element
is longer than the first:
new ArrayElement(Array("hello")) above
new ArrayElement(Array("world!"))
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 10.14 Chapter 10 · Composition and Inheritance 232
import Element.elem
abstract class Element {
def contents: Array[String]
def width: Int =
if (height == 0) 0 else contents(0).length
def height: Int = contents.length
def above(that: Element): Element =
elem(this.contents ++ that.contents)
def beside(that: Element): Element =
elem(
for (
(line1, line2) <- this.contents zip that.contents
) yield line1 + line2
)
override def toString = contents mkString "\n"
}
Listing 10.11 · Class Element refactored to use factory methods.
Similarly, evaluating the following expression would not work properly, be-
cause the first ArrayElement has a height of two, and the second a height of
only one:
new ArrayElement(Array("one", "two")) beside
new ArrayElement(Array("one"))
Listing 10.13 shows a private helper method, widen, which takes a width
and returns an Element of that width. The result contains the contents of
this Element, centered, padded to the left and right by any spaces needed
to achieve the required width. Listing 10.13 also shows a similar method,
heighten, which performs the same function in the vertical direction. The
widen method is invoked by above to ensure that Elements placed above
each other have the same width. Similarly, the heighten method is invoked
by beside to ensure that elements placed beside each other have the same
height. With these changes, the layout library is ready for use.
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 10.14 Chapter 10 · Composition and Inheritance 233
object Element {
private class ArrayElement(
val contents: Array[String]
) extends Element
private class LineElement(s: String) extends Element {
val contents = Array(s)
override def width = s.length
override def height = 1
}
private class UniformElement(
ch: Char,
override val width: Int,
override val height: Int
) extends Element {
private val line = ch.toString
*
width
def contents = Array.make(height, line)
}
def elem(contents: Array[String]): Element =
new ArrayElement(contents)
def elem(chr: Char, width: Int, height: Int): Element =
new UniformElement(chr, width, height)
def elem(line: String): Element =
new LineElement(line)
}
Listing 10.12 · Hiding implementation with private classes.
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 10.14 Chapter 10 · Composition and Inheritance 234
import Element.elem
abstract class Element {
def contents: Array[String]
def width: Int = contents(0).length
def height: Int = contents.length
def above(that: Element): Element = {
val this1 = this widen that.width
val that1 = that widen this.width
elem(this1.contents ++ that1.contents)
}
def beside(that: Element): Element = {
val this1 = this heighten that.height
val that1 = that heighten this.height
elem(
for ((line1, line2) <- this1.contents zip that1.contents)
yield line1 + line2)
}
def widen(w: Int): Element =
if (w <= width) this
else {
val left = elem(' ', (w - width) / 2, height)
var right = elem(' ', w - width - left.width, height)
left beside this beside right
}
def heighten(h: Int): Element =
if (h <= height) this
else {
val top = elem(' ', width, (h - height) / 2)
var bot = elem(' ', width, h - height - top.height)
top above this above bot
}
override def toString = contents mkString "\n"
}
Listing 10.13 · Element with widen and heighten methods.
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 10.15 Chapter 10 · Composition and Inheritance 235
10.15 Putting it all together
A fun way to exercise almost all elements of the layout library is to write
a program that draws a spiral with a given number of edges. This Spiral
program, shown in Listing 10.14, will do just that:
import Element.elem
object Spiral {
val space = elem(" ")
val corner = elem("+")
def spiral(nEdges: Int, direction: Int): Element = {
if (nEdges == 1)
elem("+")
else {
val sp = spiral(nEdges - 1, (direction + 3) % 4)
def verticalBar = elem('|', 1, sp.height)
def horizontalBar = elem('-', sp.width, 1)
if (direction == 0)
(corner beside horizontalBar) above (sp beside space)
else if (direction == 1)
(sp above space) beside (corner above verticalBar)
else if (direction == 2)
(space beside sp) above (horizontalBar beside corner)
else
(verticalBar above corner) beside (space above sp)
}
}
def main(args: Array[String]) {
val nSides = args(0).toInt
println(spiral(nSides, 0))
}
}
Listing 10.14 · The Spiral application.
Because Spiral is a standalone object with a main method with the
proper signature, it is a Scala application. Spiral takes one command-line
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 10.16 Chapter 10 · Composition and Inheritance 236
argument, an integer, and draws a spiral with the specified number of edges.
For example, you could draw a six-edge spiral as shown below on the left,
and larger spirals as shown to the right:
$ scala Spiral 6 $ scala Spiral 11 $ scala Spiral 17
+----- +---------- +----------------
| | |
| +-+ | +------+ | +------------+
| + | | | | | | |
| | | | +--+ | | | +--------+ |
+---+ | | | | | | | | | |
| | ++ | | | | | +----+ | |
| | | | | | | | | | |
| +----+ | | | | | ++ | | |
| | | | | | | | | |
+--------+ | | | +--+ | | |
| | | | | |
| | +------+ | |
| | | |
| +----------+ |
| |
+--------------+
10.16 Conclusion
In this section, you saw more concepts related to object-oriented program-
ming in Scala. Among others, you encountered abstract classes, inheritance
and subtyping, class hierarchies, parametric fields, and method overriding.
You should have developed a feel for constructing a non-trivial class hierar-
chy in Scala. We’ll work with the layout library again in Chapter 14.
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Chapter 11
Scala’s Hierarchy
Now that you’ve seen the details of class inheritance in the previous chapter,
it is a good time to take a step back and look at Scala’s class hierarchy as a
whole. In Scala, every class inherits from a common superclass named Any.
Because every class is a subclass of Any, the methods defined in Any are
“universal” methods: they may be invoked on any object. Scala also defines
some interesting classes at the bottom of the hierarchy, Null and Nothing,
which essentially act as common subclasses. For example, just as Any is a
superclass of every other class, Nothing is a subclass of every other class.
In this chapter, we’ll give you a tour of Scala’s class hierarchy.
11.1 Scala’s class hierarchy
Figure 11.1 shows an outline of Scala’s class hierarchy. At the top of the
hierarchy is class Any, which defines methods that include the following:
final def ==(that: Any): Boolean
final def !=(that: Any): Boolean
def equals(that: Any): Boolean
def hashCode: Int
def toString: String
Because every class inherits from Any, every object in a Scala program can
be compared using ==, !=, or equals; hashed using hashCode; and for-
matted using toString. The equality and inequality methods, == and !=,
are declared final in class Any, so they cannot be overridden in subclasses.
In fact, == is always the same as equals and != is always the negation of
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 11.1 Chapter 11 · Scala’s Hierarchy 238
equals. So individual classes can tailor what == or != means by overriding
the equals method. We’ll show an example later in this chapter.
The root class Any has two subclasses: AnyVal and AnyRef. AnyVal is
the parent class of every built-in value class in Scala. There are nine such
value classes: Byte, Short, Char, Int, Long, Float, Double, Boolean, and
Unit. The first eight of these correspond to Java’s primitive types, and their
values are represented at run time as Java’s primitive values. The instances of
these classes are all written as literals in Scala. For example, 42 is an instance
of Int, 'x' is an instance of Char, and false an instance of Boolean. You
cannot create instances of these classes using new. This is enforced by the
“trick” that value classes are all defined to be both abstract and final. So if
you were to write:
scala> new Int
you would get:
<console>:5: error: class Int is abstract; cannot be
instantiated
new Int
ˆ
The other value class, Unit, corresponds roughly to Java’s void type; it is
used as the result type of a method that does not otherwise return an interest-
ing result. Unit has a single instance value, which is written (), as discussed
in Section 7.2.
As explained in Chapter 5, the value classes support the usual arithmetic
and boolean operators as methods. For instance, Int has methods named +
and
*
, and Boolean has methods named || and &&. Value classes also inherit
all methods from class Any. You can test this in the interpreter:
scala> 42.toString
res1: java.lang.String = 42
scala> 42.hashCode
res2: Int = 42
scala> 42 equals 42
res3: Boolean = true
Note that the value class space is flat; all value classes are subtypes of
scala.AnyVal, but they do not subclass each other. Instead there are im-
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 11.1 Chapter 11 · Scala’s Hierarchy 239
java.lang
String
scala
Boolean
scala
Iterable
scala
Any
scala
AnyVal
scala
Unit
scala
Double
scala
Float
scala
Char
scala
Long
scala
Int
scala
Short
scala
Byte
scala
Nothing
scala
ScalaObject
scala
Seq
scala
List
scala
Null
scala
AnyRef
«java.lang.Object»
... (other Scala classes) ...
... (other Java classes) ...
Implicit Conversion
Subtype
Figure 11.1 · Class hierarchy of Scala.
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index
Section 11.1 Chapter 11 · Scala’s Hierarchy 240
plicit conversions between different value class types. For example, an in-
stance of class scala.Int is automatically widened (by an implicit conver-
sion) to an instance of class scala.Long when required.
As mentioned in Section 5.9, implicit conversions are also used to add
more functionality to value types. For instance, the type Int supports all of
the operations below:
scala> 42 max 43
res4: Int = 43
scala> 42 min 43
res5: Int = 42
scala> 1 until 5
res6: Range = Range(1, 2, 3, 4)
scala> 1 to 5
res7: Range.Inclusive = Range(1, 2, 3, 4, 5)
scala> 3.abs
res8: Int = 3
scala> (-3).abs
res9: Int = 3
Here’s how this works: The methods min, max, until, to, and abs are all
defined in a class scala.runtime.RichInt, and there is an implicit con-
version from class Int to RichInt. The conversion is applied whenever a
method is invoked on an Int that is undefined in Int but defined in RichInt.
Similar “booster classes” and implicit conversions exist for the other value
classes. Implicit conversions will be discussed in detail in Chapter 21.
The other subclass of the root class Any is class AnyRef. This is the
base class of all reference classes in Scala. As mentioned previously, on the
Java platform AnyRef is in fact just an alias for class java.lang.Object.
So classes written in Java as well as classes written in Scala all inherit from
AnyRef.
1
One way to think of java.lang.Object, therefore, is as the way
AnyRef is implemented on the Java platform. Thus, although you can use
Object and AnyRef interchangeably in Scala programs on the Java platform,
the recommended style is to use AnyRef everywhere.
1
The reason the AnyRef alias exists, instead of just using the name java.lang.Object,
is because Scala was designed to work on both the Java and .NET platforms. On .NET,
AnyRef is an alias for System.Object.
Cover · Overview · Contents · Discuss · Suggest · Glossary · Index