Scala for the Impatient

OOP1: Classes and Objects

Declare classes, instance variables, and methods

Classes

A simple class:

class Point(val x: Double, val y: Double) {
  def move(dx: Double, dy: Double) = new Point(x + dx, y + dy)
  def distanceFromOrigin = math.sqrt(x * x + y * y)
  override def toString = f"(${x}, ${y})"
}

Three methods: move, distanceFromOrigin, toString
Need override when overriding methods (here Object.toString)
No () for parameterless accessor methods
Two instance variables x, y with getters, call p.x, p.y
Unrelated aside—string interpolation:
```
f"Hello, ${name}!"
```
fills the value of the expression name into the string.
Works with printf-style formatters: f"${x}%8.2f"

Appreciate the benefit of immutabilty

Immutable and Mutable Classes

Point is an immutable class—can't change the val fields:
- p.x, p.y can only be used to read, not to mutate, the instance fields
- move yields a new object!
Prefer immutable classes:
- Sharing is safe
- Especially important in concurrent programs

Use var for mutable instance variables:

class Point(var x: Double, var y: Double)

Then you can assign to p.x, p.y.

Can also have private var or val:

class BankAccount {
  private var balance = 0.0
  ...
}

Understand object construction and class parameters

Constructors

Consider this class:

class Point(val x: Double, val y: Double) {
  def this() { this(0, 0) }
  ...
 }

A “primary constructor” called as new Point(3, 4)
An “auxiliary constructor” called as new Point()
Could have eliminated the auxiliary constructor by using default args:
```
class Point(val x: Double = 0, val y: Double = 0)
```

Can have arbitrary code in class body—part of primary constructor:

class Point(val x: Double, val y: Double) {
  println(f"Welcome to (${x}, ${y})")
    // Printed whenever a new point is constructed
  ...
}

Understand the uniform access principle

The Uniform Access Principle

In the expression p.x, you don't know whether x is a field or a method.
x could have been defined as a field:
```
class Point(val x: Double, ...)
```

Or x could have been a method:

class Point(...) {
  private val r = ...
  private val theta = ...
  def x = r * cos(theta)
  ...
}

“Uniform access” means the class user doesn't know or care.
The implementor can switch between fields and methods without changing the interface.
No need to fear public instance variables.

Use the operator notation for binary methods

More About Methods

Infix notation: x op y is the same as x.op(y).
Example:
```
1 to 10 map (3 * _) filter (_ % 5 == 2)
```

Identifiers (method names, etc.) can be sequences of symbols:

class Point(...) {
  ...
  def *(factor: Double) = new Point(x * factor, y * factor)
}

Call as p.*(2) or p * 2, whichever you prefer.
If an operator ends in :, it is right-associative.
For example, consider the following expression:
```
1 :: 2 :: 3 :: Nil 
```
The parentheses group to the right:
```
1 :: (2 :: (3 :: Nil))
```
To implement “function call” notation, provide an apply method: map(key) is map.apply(key).

Understand objects and the role of companion objects

Objects

Use object for singletons, static methods:

object Accounts {
  private var lastNumber = 0
  def newUniqueNumber() = { lastNumber += 1; lastNumber }
    // Aside: Use () since it mutates state
}

An object extending App is like main:

object MyApp extends App {
   println(f"Hello, ${args(0)}!")
}

Companion Objects

“Companion object” of class = object with the same name in the same source file:
```
class Point { ... }
object Point { ... }
```
Have access to each other's private features.

Common to have apply in companion object for factory methods:

object Point {
  def apply(x: Double, y: Double) = new Point(x, y)
}

Client doesn't call new:

val p = Point(3, 4) * factor
  // prettier than new Point(3, 4)

Practice declaring classes, instance variables, methods, and operators

Lab

Scary looking lab

Part 1: It's About Time

Write a class Time with read-only fields hours and minutes, a method toString, and a method before(other: Time): Boolean that checks whether this time comes before the other. A Time object should be constructed as new Time(h, m), where h is between 0 and 23 and m between 0 and 59. If they aren't, call throw new IllegalArgumentException.
Construct a couple of Time objects and test your before method.
Make it so that a full hour can be constructed as new Time(hrs). There are two different ways. What are they?

Part 2: Uniform Access

In a new worksheet, reimplement the Time class from the preceding exercise so that the internal representation is the number of minutes since midnight (between 0 and 24 × 60 – 1). Do not change the public interface.

Do not use var or val in the primary constructor!
```
class Time(h: Int, m: Int) {
  private val minutesSinceMidnight = ...
  ...
}
```
Supply parameterless methods hours, minutes.
Now we'll make this a little harder. In the original class, make minutes into a mutable field, so that the following is okay:
```
val start = new Time(13, 0)
start.minutes = 15
```
What did you have to do?
Do the same for the reimplemented class. You need to provide a setter method with the special name property_=, like this:
```
def minutes_=(newValue: Int) { ... }
```
In the original implementation, as changed in part 2b, it would have been possible to corrupt the field values by calling:
```
start.minutes = -100
```
How can you avoid that in the modified implementation?
Explain what “uniform access” means in this context. What changes does a programmer using the Time class have to make when switching from the original to the reimplemented class?
Why are getters and setters less evil in Scala than in Java?

Part 3: Operators

Do the following with either the original or the reimplemented Time class (your choice):

Change the before method of part 1 so that one can call:
```
if (t1 < t2) ...
```
Add a method - that, given a Time object, yields the number of minutes between them (between -1439 and 1439).
Make it so that a Time object can be constructed without calling new.