Download - Programming in scala - 1
Programming in ScalaBy: http://changingtechblog.blogspot.in/
Why Scala
● Java did wonderful things with its motto of "write once and run everywhere" but thats half the story
● Abundance of boilerplate in java● Java provided lower level of abstraction but its very
difficult to write multithreaded applications in java which runs as expected
● Multi core processors has opened an entire new dimension in programming world
● Thread safety, Visibility of data(Concurrency)● Java as a language hasn't evolved much since its
inception but JVM has evolved up to the extent that its performance has surpassed with native written code
What is Scala
● Scala is port of many years of academic research on JVM
● SCAlable LAnguage● Statically typed
○ A variable is bound to a particular type for its lifetime its type can't be changed and it can only reference type-compatible instances
○ In dynamic typing the type is bound to a value not the variable so a variable might refer to a value of type A then be reassigned to a value of unrelated type X
○ Ruby, Python, Groovy, Javascript and Smalltalk are dynamically typed
What is Scala
● Scripting language● Functional language● Object Oriented language● Concise and flexible syntax● Sophisticated type system● Scalable (performance)
JVM Languages
ScalaOther JVMLanguages
JAVA
iconst_1istore_1iconst_1istore_2iload_1iload_2iaddint2byteistore_3iload_3ireturn
JVM
Clojure, Groovy, JRuby, Jython, Rhino, Fantom, Kotlin ...see also
Installation
● Unix○ Command line Download, Extract jar file and add its
"bin" directory in classpath○ Scala IDE Download
● Windows○ Command line Download, Extract jar file and add its
"bin" directory in path variable○ Scala IDE Download
● Other methods○ Download STS or Eclipse and add scala ide as a
plugin○ Download Intellij-Idea community version and install
scala as a plugin
A taste of Scala● REPL (Read eval print loop)● $ scala● scala>● scala> :help● scala> :imports● scala> println("Hello World")● scala> printf("%d", 1)● scala> 1 + 2
res0: Int = 3● scala> 1 + "to string will be called"
res1: String = 1to string will be called● Scala worksheet in eclipse
A taste of Scala Continued ...class Upper {
def upper(strings : String*) : Seq[String] = {strings.map((s : String) => s.toUpperCase())
}}val up = new Upperprintln(up.upper("I", "am", "using", "Scala", "as", "scripting", "language"))run as - scala upper-script.scala
object Upper {def main(args : Array[String]) = {
args.map((s : String) => s.toUpperCase()).foreach(printf("%s ", _))println("")
}}run as - scalac upper.scalascala -cp . Upper I am using scala from compiled file
Type less do more● No Semicolons
○ Fewer characters to clutter your code○ Increases code readability by breaking statements in
separate line● Curly braces are not mandatory in all cases
○ class A○ def add(a : Int, b : Int) = a + b
● 'return' keyword is optional ● Method without parentheses and dots
○ "hello".length() vs "hello".length vs "hello" length○ 1. +(2) vs 1 + 2○ def isEven(n : Int) = n % 2 == 0○ List(1,2,3,4) filter isEven foreach println
● if statements are expressions in scala so there is no special ternary conditional expression
Variable declaration● val
○ immutable (read only)○ scala> val array : Array[String] = new Array(5)
scala> array(0) = "Hello"scala> array
○ scala> val list : List[Int] = List(1,2,3)scala> 23 :: listscala> list
● var○ mutable ○ can assign a new value as often as you want
● Both val and var must be initialized when declared except in abstract types and constructor arguments
● Scala encourages you to use immutable variables whenever possible
Literals● Integer literals
○ Byte, Char, Short, Int, Long○ 'l' or 'L' is required for Long
● Floating-Point literals○ Float, Double○ 'f' or 'F' is required for Float○ 'd' or 'D' is optional for Double
● Boolean (true, false)● Character literals
○ Printable unicode character or an escape sequence written between single quotes. Try '\u0041'
● String literals○ Sequence of characters enclosed in double quotes or
triples of double quotes. Try "Tab\tis escaped", """Tab\tis not escaped in triples of double quotes"""
Literals Continued ...● Symbol literals
○ symbols are single quote followed by a letter followed by zero or more digits or letters
○ these are interned strings meaning two symbols with same name will actually refer to same objects.
○ Try 'id, '1○ Not used much in scala but popular in other
languages like Ruby, Smalltalk and Lisp● Tuples
○ To return multiple values in java either pass it in method parameters or return a object or a class which contains these values
○ scala has built in support for tuples of members from 1 to 22
○ scala> val pair = (1, "Hello")
Literals Continued ...● Function literals
○ Function literal is an alternate syntax to define a function
○ val add = (a : Int, b : Int) => a + b○ val test = () => System.getProperty("user.dir")○ Useful for passing as argument in higher order
functions● Other literals
○ List■ val v1 = Nil■ val fruit = List("orange", "mango")
○ Map■ val stateCapital = Map("UP" -> "Lucknow",
"Bihar" -> "Patna") ■ val districtCount = Map(("UP", 84), ("Bihar", 40))
Identifirs● Scala allows all printable ASCII characters
except parenthetical characters ( ) [ ] { } and delimeter characters ` ' " . , ;
● It also allows operator characters such as + - % / < > etc
● Reserved words can't be used● Underscore is important it tells the compiler to
treat all characters up to next whitespace as part of identifier
● After underscore you can have either letters and digits or a sequence of operator characters but you can't mix them with letters and digits
● An identifier can also be arbitrary string between two back quote characters
Classesclass Person(firstName : String, lastName : String, age : Int) {}
● Primary Constructor - defined with class declaration● Auxiliary Constructor - defined as a method this(.....)● Constructor arguments can have access modifier such as
private, protected etc.● Arguments in primary constructor becomes instance
variables with setters and getters automatically generated depending upon variable scope, like val, var private, protected.
● Methods, instance variables can be overridden in subclass using override keyword Example: 'override def toString = "" '
Classes continued ...Subclass must extend one of the constructor of superclassclass Person(name : String, val age : Int) {
def this() = this("No name", 25)def incrementAge(value : Int) = age += value
}// Extending primary constructorclass SmartPerson(name : String, override val age : Int) extends Person(name, age)*** override keyword is must with vals// Extending Auxiliary constructorclass UnknownPerson extends Person {
override def incrementAge(value : Int) = {if(value > 0) super.incrementAge(value) else throw new Error("Value can't be < 0)
Method declaration
● Starts with a def keyword followed by optional argument list, a colon character and the return type of the method, an equal sign and finally the method body
● Method arguments can have default value● Method parameter order can be changed by
caller● Method definition can also be nested
Abstract Class● Starts with abstract keyword, It can have both primary and auxiliary
constructors● If a method doesn't have a body then it automatically becomes
abstract same for instance variables● Abstract method must only be declared in abstract class or traits
but not in concrete class● Abstract class may not contain any abstract method or field but its
subclass must override all abstract members except if it another abstract class or traitabstract class Vehicle(val model : String) {
val engineNumber : Stringvar fuel : Doubledef addFuel(amount : Double) }
class Car(override val model : String) extends Vehicle(model) {val engineNumber = "dfdf"var fuel = 0def addFuel(amount : Double) ... }
equals and hashcode
● java 'equals' equivalent in scala is 'eq'● See Scala Source Code● Scala provides 3 methods for checking equality of
objects/references● eq -> final method in AnyRef, checks equal reference● equals -> calls eq in AnyRef, must override it if you want to
check object equality instead of reference equality, structure def equals(that : Any) "that must be Any"
● == -> final method which calls equals with null checked● ne -> anti of eq● must override hashcode whenever overriding equals● Example in Person class
Companion Object● A way to create singleton object, and separate class level
stuffs with object level stuff● starts with 'object' keyword in place of 'class' in class
declaration except that it has only default constructor● It must be defined in same file with same name as actual
class for which it is a companion object● apply, unapply methods
class Rational(x: Int, y: Int) { ... }object Rational {
def apply(x : Int, y : Int) = new Rational(x, y)def unapply(rational : Rational) = if(rational == null) None else
Some(rational.numer, rational.denom)
● Now we can define val rational = Rational(23, 45)
val Rational(x : Int, y : Int) = Rational(4, 5)
Use of None instead of null● Scala discourages the use of null to avoid
NullPointerException or unnecessary null check● It provides two implementations of Option[+A] sealed
abstract class● None -> container has no value● Some -> container has some value● If a method can return null then it must be returned as Option
[A]● Always try to use getORElse rather than getExample:scala> var x : Option[String] = Nonescala> x.getscala> x.getOrElse("No Value")scala> x = Some("has some value")scala> x.getOrElse("No Value")scala> x = Option(null)scala> x = Option("Something")
Discussions
● List, Vector, Stream● Last session exercises● Package objects● File IO
Traits● Same as java interfaces with ability to have
implementation of methods and variable declaration
● It solves boilerplate code generated with using java interface
● It also gives ability to compose behaviour on demand
trait Culturetrait SouthIndianCulture extends Culturetrait BihariCulture extends Culturetrait ModernCulture extends Cultureclass Person extends Cultureval mukesh = new Person with BihariCulture with ModernCultureval modernPerson = new Person with ModernCultureval idiot = new Person
Traits Contd ...● Traits can't have primary or auxiliary constructors● A class can mixin multiple traits using "with" keyword except first
trait starts with "extends"● It has a well defined algorithm for the order in which it is called
when a class is mixed in with multiple traits● It provides late binding "super call from a trait depends upon the
order in which it is mixing in"trait Atrait B extends Atrait C extends Bclass D extends A with B with C*Start with Class and then from right to left write its name expand if neededD - The classD C B A - Expande CD C B A B A - Expand BD C B A B A A - Expand ANow starting from right keep first one and remove any other repetition of that typeD C B A ScalaObject AnyRef Any - This will be final call order
Traits Contd ...● Traits can extend a class, abstract class which has no
parameter primary or auxiliary constructor● self type - mechanism to refer to "this"trait T1trait T2 {
self =>}trait T3 {
self : T1 =>}// fineclass C extends T2// Compilation error, it must extend T1 because it was force in // definition of T3class C1 extends T3
Types● Type is a set of information the compiler knows which is
used to infer whether a statement will succeed or fail● In Scala A type can be one of object, class, trait or
defined with type keyword● class and trait types are accessible directly but object
types are accessed with objectname.type● Structural type defines what method/variable signature
you might expect on a particular type. It should be avoided as it uses reflection
Exampleobject Otype abstractTypetype concreteType = Stringtype concreteType = C with Ttype objectType = O.type
Structural Types// A type closeable must have close methodtype Closeable = {def close : Unit}
// Define a method with parameter closeabledef testClose(closeable : Closeable) = closeable.close
// We can call this method on any class or trait which has// close method in its scope, above method is applicable for all threeclass C { def close = println("closing in C") } trait T { def close = println("closing in T") } class C1 extends T
Thank You
http://changingtechblog.blogspot.in/