Scala for the Impatient

OOP2: Packages, Inheritance, and Traits

Understand packages and package nesting

Packages

• Purpose of package: unique names.

  val now = new java.util.Date // and not java.sql.Date

• Scala packages nest:

  package com {
    package horstmann {
      package impatient {
        class Employee 
        ...
      }
    }
  }

  Fully qualified name: com.horstmann.impatient.Employee
• Just like nested classes

Packages

• As in Java, a Scala package can have contributions from multiple source files.
• In Scala, can have contributions to multiple packages in a single source file.
• In Scala, no relationship between packages and source directories.
• Top-of file package statement without braces:

  package com.horstmann.impatient
  

  Like in Java: The entire source file is in this package.

Work with import statements

Imports

• Purpose of imports: short names.

  import java.util.Date
  val now = new Date // shortcut for new java.util.Date
  

• Wildcard imports use the Scala wildcard symbol:

  import java.util._
  import java.lang.Math._ // like import static in Java

• Other variants:

  import java.awt.{Color, Font} // import two classes
  import java.util.{HashMap => JavaHashMap} // alias 
  import java.util.{HashMap => _, _} // hide a class
  

Imports 2

• Imports can be anywhere:

  class Manager {
    import scala.collection.mutable._
    val subordinates = new ArrayBuffer[Employee]
    ...
  }

• java.lang, scala, Predef are always imported.

Package Nesting

• Java packages do not nest—no relationship between java.util and java.util.regex.
• Scala packages nest:

  package com {
    package horstmann {
      object App {
        def run { ... }
      }
      package impatient {
        new App(...)
      }
    }
  }

• Caution: Names can be either relative or absolute. App could be com.horstmann.App or scala.App.
• Use _root_.scala.App to disambiguate.

Declare subclasses and traits

Inheritance

• Subclass declaration like in Java:

  class Manager extends Employee

• Run-time type inquiry:

  e.isInstanceOf[Manager] // like e instanceof Manager
  e.asInstanceOf[Manager] // like (Manager) e
  e.getClass == classOf[Manager] // like Manager.class
  

• Superclass construction:

  class Employee(name: String, age: Int, val salary: Double)
    extends Person(name, age)

Traits L1

• Superficially similar to Java interface
• A class can extend multiple traits:

  class Employee extends Person with Cloneable with Serializable

• Traits can have concrete methods (like Java 8 default methods).
• Traits can have abstract fields.
  • A concrete implementing class must supply them.
• Traits can have concrete fields.
  • Concrete trait fields are added to the implementing class.
• Traits cannot have construction parameters.
  • Technically, this is the only difference between classes and traits.

Understand mixins and layered traits

Mixins

• Use traits to “mix in” small amounts of functionality into a class:

  class ArrayBuffer[A] extends AbstractBuffer[A]
     with Buffer[A] with GenericTraversableTemplate[A, ArrayBuffer]
     with BufferLike[A, ArrayBuffer[A]]
     with IndexedSeqOptimized[A, ArrayBuffer[A]]
     with Builder[A, ArrayBuffer[A]] with ResizableArray[A]
     with CustomParallelizable[A, ParArray[A]] with Serializable

• Can also mix into objects:

  trait Logged {
    def log(msg: String) {}
  }
  
  trait ConsoleLogger extends Logged {
    override def log(msg: String) { println(msg) }
  }
  
  class SavingsAccount extends Logged {
    private var balance: Double = 0
    def withdraw(amount: Double) {
      if (amount > balance) log("Insufficient funds")
      else balance -= amount
    }
    // ...
  }
  
  val acct = new SavingsAccount with ConsoleLogger
  val acct2 = new SavingsAccount with FileLogger
  

Layers

• Trait methods can invoke others in a prior layer:

  trait TimestampLogger extends Logged {
    override def log(msg: String) {
      super.log(new java.util.Date() + " " + msg)
    }
  }
    
  trait ShortLogger extends Logged {
    val maxLength = 15
    override def log(msg: String) {
      super.log(
        if (msg.length <= maxLength) msg 
        else msg.substring(0, maxLength - 3) + "...")
    }
  }
  
  val acct1 = new SavingsAccount with ConsoleLogger
    with TimestampLogger with ShortLogger
  acct1.withdraw(1000) // Sun Nov 01 17:45:45 ICT 2015 Insufficient...  
  

Practice working with traits

Lab

Part 1: Mixing in Missing Methods

1. The java.awt.Rectangle class has a method translate that moves a rectangle by a given amount. Try it out: In a worksheet, import the java.awt package, construct a new Rectangle(5, 10, 20, 30), call translate(10, 20), and see what its coordinates are now.
2. To make ellipses, you use the class java.awt.geom.Ellipse2D.Double. Make an instance val egg = new geom.Ellipse2D.Double(5, 10, 20, 30). Why didn't you have to put java.awt before geom?
3. Now call egg.translate(10, 20). What happens?
4. That's eggsasperating. Why didn't they add the method to Ellipse2D, or better, its superclass RectangularShape? We can fix that in Scala. Define a trait:

   trait RectangleLike {
       def setFrame(x: Double, y: Double, w: Double, h: Double): Unit
       def getX: Double
       def getY: Double
       def getWidth: Double
       def getHeight: Double
       def translate(dx: Double, dy: Double) { setFrame(getX + dx, getY + dy, getWidth, getHeight) }
     }
   

   Now change the definition of egg so that the call to translate works. What did you do?

Part 2: Reversing the Mixin Order

1. Run through the “Layers” example and reverse the order of the mixins:

   val acct2 = new SavingsAccount
     with ConsoleLogger with ShortLogger with TimestampLogger {
     override val maxLength = 20
   }

   Without running the program, what do you think will happen when you call acct2.withdraw(1000)?
2. Now run the program. Were you right?
3. What happens when you try the following?

   val acct3 = new SavingsAccount
     with ShortLogger with TimestampLogger with ConsoleLogger 
   

Part 3: Buffering

1. In the java.io library, one has to work hard to get services such as buffering:

   new BufferedReader(new InputStreamReader(new FileInputStream("/usr/share/dict/words")))

   It shouldn't be so hard to add buffering. (Buffering means not to read each byte separately but to read them a chunk at a time.) Here is a Scala trait:

   trait Buffered extends InputStream {
        val SIZE = 1024
        private var end = 0
        private val buffer = new Array[Byte](SIZE)
        private var pos = 0
        
        override def read() = {
          if (pos == end) {
            end = super.read(buffer, 0, SIZE)
            pos = 0
          }
          if (pos == end) -1 else {
            pos += 1
            buffer(pos - 1)
          }
        }
     }
   

   Mix in Buffered into a new FileInputStream("/usr/share/dict/words") (or some other file if you aren't running Linux/Mac OS). How do you do that? Then call read a few times. What do you get?
2. How can you tell that buffering happens? Mix in a logger!