Scala. Fernando Medeiros Tomás Paim

Transcription

1 Scala Fernando Medeiros Tomás Paim

2 Topics A Scalable Language Classes and Objects Basic Types Functions and Closures Composition and Inheritance Scala s Hierarchy Types Parametrization Traits Annotations Assertions and Unit Testing

3 A Scalable Language Name stands for scalable language Compiles to JVM bytecodes Object-oriented Follows Smalltalk concept Combines data with operations under a formalized interface Functional

4 A Scalable Language Concise Compatible with Java designed for interoperability with Java, as Scala can inherit from Java classes, call Java methods, access Java fields and implement Java interfaces Statically typed even though compiler can infer return types, is a good practice to make it explicit Allows generics

5 A Scalable Language // Java class definition class MyClass { private: int index; private: String name; // Scala class definition class MyClass(index: Int, name: String) public MyClass(int index, String name) { } } this.index = index; this.name = name;

6 Classes and Objects Syntax similar to Java To instantiate an object of a class: val myobj = new MyClass(42, foo ) But not that much Inside classes or companion object, what is not private, is public by default val members cannot have their value modified, while var ones may have Singleton object definition is one-liner Classes may have a singleton object companion

7 Classes and Objects class MyClass(index: Int, name: String) { } def doublefoo = MyClass.foo * 2 def baz { } println("baz") object MyClass { def foo: Int = 42 def bar = "bar" def newbaz { val myclassobject = new MyClass(42, "foo") myclassobject.baz } }

8 Basic Types Basic Types Value Type Byte Range 8-bit signed two s complement integer (-27 to 27-1, inclusive) Short 16-bit signed two s complement integer (-215 to 215-1, inclusive) Int 32-bit signed two s complement integer (-231 to 231-1, inclusive) Long 64-bit signed two s complement integer (-263 to 263-1, inclusive) Char String Float Double Boolean 16-bit unsigned Unicode character (0 to 216-1, inclusive) a sequence of Chars 32-bit IEEE 754 single-precision float 64-bit IEEE 754 double-precision float true or false

9 Basic Types Operators are methods invokes 1.+(2) Any method can be an operator Str.indexOf( o ) method is being invoked Str indexof o indexof is an operator

10 Functions and Closures Functions are first-class values Scala offers several ways to break the code into smaller pieces Methods Local and anonymous functions def factorial(n: Int): Int = { def loop(n: Int, acc: Int): Int = if (n < 1) acc else loop(n - 1, n * acc) loop(n, 1) }

11 Functions and Closures Chain calls def stdev(l: List[Double]): Double = scala.math.pow(l.map(_ - l.sum / l.length).map(scala.math.pow(_, 2)).sum / (l.length),.5) Closures Yield keyword may be used to return some value to a code block Both expressions below are equivalent: list.filter(_ > 2) for (l <- list if l > 2) yield l Scala offers lazy evaluation of vals and functions arguments

12 Functions and Closures

13 Composition and Inheritance Inheritance in Scala works in a way similar to Java, using keyword extends. Even though it doesn t allow multiple inheritance, traits can be mixed in with classes There is the concept of abstract class, where there may be unimplemented methods An abstract class can t be instantiated. It is required to extend it to a concrete class, then instantiate the concrete one Functions can be overridden in subclasses, using keyword override (final keyword is used to disallow overriding a method, or extending a class) tostring method may be overridden in any class, to customize the way you print the elements of the class

14 Composition and Inheritance

15 Composition and Inheritance One way to create composition relationship between classes in Scala is through abstract classes abstract class Element { } def contents: Array[String] val height = contents.length val width = if (height == 0) 0 else contents(0).length class ArrayElement(conts: Array[String]) extends Element { } def contents: Array[String] = conts

16 Scala s Hierarchy

17 Types Parametrization It is possible to parametrize classes with types parameters bounds, in the case of generic parametrization. T <: Type The parameter passed as T must be something more specific than type Type, i.e. below the hierarchy of Type T >: Type The parameter passed as T must be something more generic than type Type, i.e. above the hierarchy of Type

18 Types Parametrization class Stone class Pebble extends Stone class Container[T <: Pebble] val contpebble = new Container[Pebble] val contstone = new Container[Stone]

19 Types Parametrization class Stone class Pebble extends Stone class Container[T >: Pebble] val contpebble = new Container[Pebble] val contstone = new Container[Stone]

20 Traits Traits encapsulate methods and field definitions, that can be reused by mixing them into classes. Commonly used when a class needs some behavior orthogonal to the class purpose. They are mixed with classes by keyword with. Not used to extend Java code directly, as there is not a direct Java equivalent of traits

21 Traits Example: trait Singer { def sing: Unit = println("sings") } abstract class Animal { def eat: Unit } abstract class Person { def think: Unit } class Bird(specie: String) extends Animal with Singer { def eat: Unit = println(s"${this.specie} is eating") } class Actor(name: String) extends Person with Singer { def think: Unit = println(s"${this.name} is acting") }

22 Annotations Automatic generation of documentation with def bigmistake =... Ensuring code //this code compiles def factorial(n: Int): Int = { def loop(n: Int, acc: Int): Int = if (n < 1) acc else loop(n - 1, n * acc) loop(n, 1) //compiler shows error in this case, as this is not a tail recursive call def factorial(n: Int): Int = { if (n < 2) 1 else n * factorial(n - 1) }

23 Assertions and Unit Testing There are several frameworks for Scala code testing: Unit tests JUnit TestNG Behavior tests Spec WordSpec FlatSpec Property-based testing ScalaCheck

24 References Programming in Scala. Odersky, Spoon and Venners Scala for the Impatient. Horstmann

25 Further Reading Functional Programming in Scala. Chiusano and Bjarnason Design patterns in Scala