scala(10)A Tour of Scala: Inner Classes

scala(10)A Tour of Scala: Inner Classes

Inner Classes

Just understand we can have inner classes

class Graph {

class Node {

var connectedNodes: List[Node] = Nil

def connectTo(node: Node) {

if (connectedNodes.find(node.equals).isEmpty) {

connectedNodes = node :: connectedNodes

}

}

}

var nodes: List[Node] = Nil

def newNode: Node = {

val res = new Node

nodes = res :: nodes

res

}

}

object GraphTest extends App {

val g = new Graph

val n1 = g.newNode

val n2 = g.newNode

val n3 = g.newNode

n1.connectTo(n2)

n3.connectTo(n1)

}

Mixin Class Composition

abstract class AbsIterator {

type T

def hasNext: Boolean

def next: T

}

trait RichIterator extends AbsIterator {

def foreach(f: T => Unit) { while (hasNext) f(next) }

}

class StringIterator(s: String) extends AbsIterator {

type T = Char

privatevari = 0

def hasNext = i < s.length()

def next = { val ch = s charAt i; i += 1; ch }

}

object StringIteratorTest extends App {

class Iter extends StringIterator("1234") with RichIterator

val iter = new Iter

iter foreach println

}

No one has the method foreach, but the trait has.

Nested Functions

…snip…

Anonymous Function Syntax

…snip…

Currying

…snip...

Automatic Type-Dependent Closure Construction

…snip...

Operators

Any method which takes a single parameter can be used as an infix operator in Scala.

class MyBool(x: Boolean){

def or(that: MyBool): MyBool = if(x) this else that

}

def xor(x: MyBool, y: MyBool) = (x or y)

Higher-Order Functions

class Decorator(left: String, right: String) {

def layout[A](x: A) = left + x.toString() + right

}

object FunTest extends App {

//defined the function, take other function and values as

//parameters

def apply(f: Int => String, v: Int) = f(v)

val decorator = new Decorator("[", "]")

println(apply(decorator.layout, 7)) //[7]

}

This function can take other functions and values as parameters and apply first.

Packages

A package is a special object which defines a set of member classes, objects and packages. Unlike other objects, packages are not introduced by a definition.

Import clauses

import p._ all members of p

import p.x the member x of p.

import p.{ x => a} the member x of p renamed as a.

import p.{x, y} the members x and y of p.

import p1.p2.z the member z of p2, itself member of p1.

import p1._, p2._ alternatively import p1._; import p2._

Implicitly imported into every compilation unit

java.lang

scala

scala.Predef

Pattern Matching

object MatchTest1 extends App {

def matchTest(x: Int): String = x match {

case 1 => "one"

case 2 => "two"

case _ => "many"

}

println(matchTest(3)) //many

}

object MatchTest2 extends App {

def matchTest(x: Any): Any = x match {

case 1 => "one"

case "two" => 2

case y: Int => "scala.Int"

}

println(matchTest("two")) //2

println(matchTest(2)) //scala.Int

println(matchTest(1))//one

}

Magic match, can be any types and even pattern.

References:

http://www.scala-lang.org/node/115

http://www.scala-lang.org/node/116

http://www.scala-lang.org/node/118

http://www.scala-lang.org/node/134