Pollak D. Beginning Scala
Подождите немного. Документ загружается.
CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
37
These methods are boilerplate. Scala provides the case class mechanism for filling in these
blanks as well as support for pattern matching. A case class provides the same facilities as
a normal class, but the compiler generates
toString, hashCode, and equals methods (which
you can override). Case classes can be instantiated without the use of the
new statement.
By default, all the parameters in the case class’s constructor become properties on the
case class. Here’s how to create a case class:
case class Stuff(name: String, age: Int)
You can create an instance of Stuff without a new (you can use new if you want):
scala> val s = Stuff("David", 45)
s: Stuff = Stuff(David,45)
The case class’s toString method does the right thing:
scala> s.toString
res70: String = Stuff(David,45)
Stuff’s equals method does a deep comparison:
scala> s == Stuff("David", 45)
res72: Boolean = true
scala> s == Stuff("David", 43)
res73: Boolean = false
19897ch02.fm Page 37 Wednesday, April 1, 2009 5:34 PM
38
CHAPTER 2
■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
And the instance has properties:
scala> s.name
res74: String = David
scala> s.age
res75: Int = 45
If you want to write your own class that does the same thing as a case class, it would
look like the following:
class Stuff(val name: String, val age: Int) {
override def toString = "Stuff("+name+","+age+")"
override def hashCode = name.hashCode + age
override def equals(other: AnyRef) = other match {
case s: Stuff => this.name == s.name && this.age == s.age
case _ => false
}
}
object Stuff {
def apply(name: String, age: Int) = new Stuff(name, age)
def unapply(s: Stuff) = Some((s.name, s.age))
}
Case classes also come in handy for pattern matching, a topic we’ll explore in the next
subsection.
Basic Pattern Matching
Scala’s pattern matching allows you to construct very complex tests in very little code.
Pattern matching is like Java’s
switch statement, but you can test against almost anything,
and you can even assign pieces of the matched value to variables. Like everything in Scala,
pattern matching is an expression, so it results in a value that may be assigned or returned.
The most basic pattern matching is like Java’s
switch, except there is no break in each case
19897ch02.fm Page 38 Wednesday, April 1, 2009 5:34 PM
CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
39
as the cases do not fall through to each other. This example matches the number against
a constant, but with a default:
44 match {
case 44 => true // if we match 44, the result is true
case _ => false // otherwise the result is false
}
Like C#, you can match against a String:
"David" match {
case "David" => 45 // the result is 45 if we match "David"
case "Elwood" => 77
case _ => 0
}
You can pattern match against case classes. Case classes provide a particularly good
set of pattern-matching semantics. In this case, we are matching against a
Stuff instance
with
name == David and age == 45 in a declarative form:
Stuff("David", 45) match {
case Stuff("David", 45) => true
case _ => false
}
We can test the name but accept any age:
Stuff("David", 45) match {
case Stuff("David", _) => "David"
case _ => "Other"
}
And we can extract the age field into the howOld variable:
Stuff("David", 45) match {
case Stuff("David", howOld) => "David, age: "+howOld
case _ => "Other"
}
We can place a guard between the pattern and the => that adds further testing that
cannot be described declaratively. In this case, we’ll extract the
age, and if it’s less than 30,
the result will be “young David”, otherwise the result will be “old David”:
Stuff("David", 45) match {
case Stuff("David", age) if age < 30 => "young David"
case Stuff("David", _) => "old David"
case _ => "Other"
}
19897ch02.fm Page 39 Wednesday, April 1, 2009 5:34 PM
40
CHAPTER 2
■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
Pattern matching can also test whether the input is an instance of a given class and do
the casting if it is:
x match {
case d: java.util.Date => "The date in milliseconds is "+d.getTime
case u: java.net.URL => "The URL path: "+u.getPath
case s: String => "String: "+s
case _ => "Something else"
}
The previous code replaces the following Java code:
if (x instanceOf Date) return "The date in milliseconds is "+((Date) x).getTime();
if (x instanceOf URL) return "The URL path: "+((URL) x).getPath();
if (x instanceOf String) return "String "+((String) x);
return "Something else";
if/else and while
It may seem strange that we’re covering simple flow of control statements late in this
section. It turns out that
while is used very rarely in Scala code. if/else is used more
frequently, a bit more frequently than the ternary operator is used in Java. The result of
if
and
while expressions is always Unit. The result of if/else is based on the type of each part
of the expression.
This will print “yes” if
exp is true:
if (exp) println("yes")
Like Java, an if expression may have a multiline code block:
if (exp) {
println("Line one")
println("Line two")
}
if
/else behaves like the ternary operator in Java:
val i: Int = if (exp) 1 else 3
and either (or both) parts of the expression may have multiline code blocks:
val i: Int = if (exp) 1
else {
val j = System.currentTimeMillis
(j % 100L).toInt
}
19897ch02.fm Page 40 Wednesday, April 1, 2009 5:34 PM
CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
41
while executes its code block as long as its expression evaluates to true, just like Java. In
practice, using recursion, a method calling itself, provides more readable code and enforces
the concept of transforming input to output rather than changing, mutating, variables.
Recursive methods can be as efficient as a while loop.
6
while (exp) println("Working...")
while (exp) {
println("Working...")
}
The for comprehension
At first blush, Scala’s for comprehension looks a lot like Java’s for loop. However, they are
significantly different. The basic form implements flow of control, executing the body one
time for each value:
scala> for {i <- 1 to 3} println(i)
1
2
3
Scala’s for comprehension allows for nesting of expressions. You don’t have multiple
for comprehensions nested in order to have nested expressions, thus there’s an entire
iteration of the inner variable,
j, for each value of the outer variable, i.
scala> for {i <- 1 to 3
j <- 1 to 3} println(i * j)
1
2
…
9
6. See http://en.wikipedia.org/wiki/Tail_recursion.
19897ch02.fm Page 41 Wednesday, April 1, 2009 5:34 PM
42
CHAPTER 2
■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
The for comprehension also supports guards:
scala> def isOdd(in: Int) = in % 2 == 1
isOdd: (Int)Boolean
scala> for {i <- 1 to 5 if isOdd(i)} println(i)
1
3
5
And the guards can be part of the expression nesting:
scala> for {i <- 1 to 5
j <- 1 to 5 if isOdd(i * j)} println(i * j)
1
3
5
3
9
15
5
15
25
I primarily use the for comprehension to transform a collection or set of collections
into a new collection. Let’s define some data:
scala> val lst = (1 to 18 by 3).toList
lst: List[Int] = List(1, 4, 7, 10, 13, 16)
19897ch02.fm Page 42 Wednesday, April 1, 2009 5:34 PM
CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
43
If the yield keyword introduces the for comprehension’s body, the for comprehension
returns a collection rather than simply calling the code block. Thus:
scala> for {i <- lst if isOdd(i)} yield i
res11: List[Int] = List(1, 7, 13)
And the nesting rules and guards work the same way:
scala> for {i <- lst; j <- lst if isOdd(i * j)} yield i * j
res12: List[Int] = List(1, 7, 13, 7, 49, 91, 13, 91, 169)
We’ve explored a little bit of the syntax of the for comprehension. In Chapter 3, we’ll
see how it can be used with a variety of collections to provide powerful, syntactically
pleasing, concise data transformations.
throw, try/catch/finally, and synchronized
Throwing exceptions is the same in Scala and Java:
throw new Exception("Working...")
The try/finally construct is the same:
try {
throw new Exception("Working...")
} finally {
println("This will always be printed")
}
The try/catch construct is different. First, it’s an expression that results in a value. This
makes it possible to wrap a call in a
try/catch and assign a default value if the call fails.
Second, the exception is pattern matched in the
catch block rather than having separate
19897ch02.fm Page 43 Wednesday, April 1, 2009 5:34 PM
44
CHAPTER 2
■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
catch clauses for each different exception. Guards are legal in the patterns as well. Here’s
a basic
try/catch expression:
try {
file.write(stuff)
} catch {
case e: java.io.IOException => // handle IO Exception
case n: NullPointerException => // handle null pointer
}
Here’s an example of calling Integer.parseInt and defaulting to 0 if an exception is
thrown:
scala> try{Integer.parseInt("dog")} catch {case _ => 0}
res16: Int = 0
scala> try{Integer.parseInt("44")} catch {case _ => 0}
res17: Int = 44
To synchronize based on an instance, call the instance’s synchronized method with a
code block:
obj.synchronized {
// do something that needs to be serialized
}
There’s no synchronized modifier for methods. Synchronize a method this way:
def foo(): Int = synchronized {
42
}
19897ch02.fm Page 44 Wednesday, April 1, 2009 5:34 PM
CHAPTER 2 ■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
45
Comments
Scala comments are much like Java and C++ comments. Multiline comments are started
with
/* and ended with */.
/*
This is a multi-line comment
*/
A single-line comment is started with // and continues to the end of the line:
// This is a single line comment
In Scala, you can nest multiline comments:
/*
This is an outer comment
/* And this comment
is nested
*/
Outer comment
*/
We’ve gone through an overview of Scala’s syntax. Now, let’s contrast Scala with Java
and Ruby.
Scala vs. Java vs. Ruby
Scala, Java, and Ruby are object-oriented languages. They share many similarities and
some differences. In this section, we’ll compare and contrast these popular languages.
Classes and Instances
Scala and Ruby are pure object-oriented languages. Everything in each language is an
instance of a class. In Java, there are primitives and statics that are outside of the OO model.
In Scala and Ruby, all operations on entities are via method calls. In Java, operators are
treated differently and are not method calls. The uniformity of instances in Scala means
19897ch02.fm Page 45 Wednesday, April 1, 2009 5:34 PM
46
CHAPTER 2
■ SCALA SYNTAX, SCRIPTS, AND YOUR FIRST SCALA PROGRAMS
that the developer does not have to perform special tests or to have different code paths
to deal with primitive data types (
int, char, long, and so on) The following is legal in Scala:
scala> 1.hashCode
res0: Int = 1
scala> 2.toString
res1: java.lang.String = 2
You can define a method that takes a function that transforms an Int to an Int:
scala> def with42(in: Int => Int) = in(42)
and pass a function that is applying the + method to 33:
scala> with42(33 +)
res4: Int = 75
At the language level, it’s very convenient and easy on the brain and the design to have
everything be uniform. Scala and Ruby’s pure OO approach achieves this goal. As a side
note, you may worry about performance. The Scala compiler optimizes operations on
JVM primitives such that the performance of Scala code is nearly identical to the perfor-
mance of Java code.
Traits, Interfaces, and Mixins
Every Java class, except Object, has a single superclass. Java classes may implement one or
more interfaces. An interface is a contract that specifies the methods an implementing
class must have. Java has interfaces. Interfaces define a contract for a given class. A class
has zero or more interfaces. Interfaces define the methods that the class must implement.
Parameters to a method call may be specifically defined as classes or interfaces. Interfaces
provide a powerful mechanism for defining the contract that a given class must implement,
requiring that a parameter to a method implement particular methods without specifying
19897ch02.fm Page 46 Wednesday, April 1, 2009 5:34 PM