Scala is a general purpose programming language that supports both object-oriented and functional programming. It was developed by Martin Odersky in 2001. Scala runs on the Java Virtual Machine and is fully interoperable with Java. Everything in Scala is an object, including functions, which are first-class citizens that can be passed as arguments to other functions. Scala uses the REPL (Read-Evaluate-Print-Loop) for interactive use and supports features like immutable collections, pattern matching, lazy evaluation, and traits similar to interfaces.

2. What is Scala
• A General purpose programming language.
• Supports both object oriented and functional programming styles.
• Martin Odersky developed Scala in 2001.

3. What is Scala
• Fully supports OOPS
• Everything is an object in Scala.
• Unlike java Scala does not have primitives.
• Functions themselves are objects in Scala.
• Functions are first class citizens in FP. Means they can be assigned to variables, passed to other functions,
etc.. Just like other values.
• Scala is a statically typed.
• Supports static class members through singleton object concept.
• Improved support for OOP through Traits.

4. Scala

5. Scala

6. Scala REPL
• REPL – Read – Evaluate – Print – Loop
• Easiest way to get started with Scala. Act as an interactive shell interpreter.
• It converts all typed code to bytecode and executed.
• Invoked by typing Scala.

7. Variable Types
• In Scala you can decide if your variables are mutable or immutable.
• Val
• Similar to Java Final Variables.
• Once initialized Val’s cant be reassigned.
• By default it assigns to val.
• Var
• Similar to non final variable in java.
• Scala infers the type.
• val a : Int = 0 is equal to val a = 0

8. Automatically initialize it to session variable res4
Automatically assigned as Integer
res is default naming convention for Scala vals.
0/1/2 followed by res is auto increment numbering
Automatically assigned as String.
Even though we never declared variable type, scala inferred it.
If you assigned a variable as val. It’s a constant and you cannot re assign it.

9. This will work because we are redefining it.
Instead of Val (read only) we are using var to assign
a variable, and hence it allows us to re assign it to
any other value.
You cannot re assign a variable to value of other
data type.
Once a type is assigned to a variable, it remains
same for entire scope.
This will not work, since val is read only (Constant)

10. Assigning Block Expression
• In an expression the last statement will be returned.

11. Lazy Values
• You can define a value as lazy in scala.
• Lazy value initialization is deferred till its accessed for first time.
If you want to read a file and if the file is not existing or present ,
you will get FileNotFoundException.
But if you initialize the value as lazy, you wont get this error,
because it will delay the initialization till it access the file.
mkString is similar to toString in java.

12. Control Structures in Scala
If Else Condition
If Else Condition where 2 different data types are returned in a
single if- else condition.
The return type will be Any class.
For each loops iterate without an iterator.

13. x.foreach is an implicit iteration where you don’t have to
create any iterator.
i <- 0 implies int i = 0
It sums every index.

14. Nested For Loop
Nested For Loop in Java
• for( int i = 0 ; i < 3; i++)
• for( int j =0 ; j<3 ; j++)
• println(i*j)
• Nested for loop in Scala
• for( i<- 1 to 3 ; j <- i to 3)
• Print(i*j)

15. Nested For Loop (Contd.)

16. Functions

17. Methoddefinition
Nameofmethod
Parameterofmethod
Datatypeofparameter
Returntypeofmethod
Bodyofmethod
Function Declaration

18. Return type Double is optional. Because return type is
dynamically inferred.
If there is only one line in body, curly braces can be
removed.
Return type is mandatory if the function is a recursive
function.

19. Named arguments.
Passing only one
argument. Cos 2nd and
3rd are has default
values.
Arguments in Functions

20. Procedures
• Procedures don’t have any return type. Its similar to functions.
• If scala has a function without a preeding “=“ symbol then the return of the function is Unit.
• Procedures do not return any value in scala.

21. Collections

22. Declare an array
Fetch value based on index
Assign value on specific index
Iterate over an array.
Array
Even though n is val. The
values can be reassigned.

23. Mutable version of array. We need to
explicitly import.
Array Buffer
Elements can be added and size can be
increase dynamically, unlike array.
Similar to Java ArrayList

24. Array Buffer and Array Functions

25. Array Buffer and Array Functions

26. By default creates
immutable map
Cannot edit an
immutable map.
Even if you create
using var. it remains
immutable.
Map

27. Map Functions

28. Mutable Map

29. Tuples
• Tuple has more than two values of potential different types.
• In tuples the offset start with 1 and Not from 0.
• Tuples are typically used for functions which return more than one value.

30. List and their Functions

31. OOPS in Scala

32. Creation object without
parenthesis
Creation object
Classes

33. Properties with Getter and Setter
• Scala generate a class for JVM with a private size variable and public getter and setter methods.
• If the field is declared as private, the getter and setter would be private.
• The getter and setter methods in previous case would be:
• size and size_ =

34. Scala generates getter and
setter methods for
member variables.
Cannot access
private variable.
And Scala does
not generate
getter and setter
for private
variable.

35. Auxiliary constructor should call default/primary constructor in first line. Or the
previous auxiliary constructor. In this case its default constructor this()
Auxiliary constructor if not primary constructor can call previous auxiliary
constructor in first line. this(age)
Auxiliary Constructor
Auxiliary constructor in scala is called this()

36. Primary Constructor
1. Every class in scala has a primary constructor.
2. Parameters for primary constructor are placed
immediately after the class name.

37. Singletons
• Scala doesn't have the concept of static methods or fields.
• It is supported by object construct.
• An object defines the single instance of class.

38. Companion Objects
• In programming languages we have both instance methods and static methods in same class.
• In Scala, it is achieved using companion objects.
• The class and its companion objects need to be in same source file.
• The companion object of the class is accessible, but NOT in scope.
• The class and its companion objects can access each other’s private features.

39. Static in Java

40. Singletons and Companion Objects
Static example in
previous slide, can be
done in scala using
companion objects.

41. Compare two objects.
The below comparison can be made simple using Case notion in Scala Classes.

42. Case Class
• Case class don’t need a constructor for them
• For case class the scala compiler:-
• Creates the class and its companion object.
• Makes all parameters as val, so we can have only accessors.

43. Extending a Class
• Just like java, classes can be extended using extends keyword.
• Just like java, new methods and fields can be introduced or superclass methods or fields could be overridden in subclasses.
• A class can be declared as final and avoid being overridden.
•

44. Extending a Final Class
• Final class can not be overridden.

45. Overriding Methods
• Override modifier must be used to override an abstract methods.
• Invoking superclass method is same as in java, by super keyword.

46. Traits as Interface
• Scala traits works exactly like java interface.
• Methods need not be declared as abstract.
• extend keyword is used to implement a trait in scala.
• with keyword is used to extend more than one interface.

47. Traits as Interface

48. Traits as Interface
• Traits can have concrete and abstract methods.
• If traits have a method with body, then the class which extends should use override keyword
while extending it.
• Traits cannot be instantiated.
• Abstract method need a definition when a trait is extended.
• Multiple traits can be overridden using with keyword.
• A namespace collision is taken care by overriding the definition of the method with the last
available definition.

49. App trait
• Since everything in scala is an object, even main method lives in a object.
• There are two ways to create a launching point for your application: define an object that extends
the App trait, or define an object with a properly defined main method.
When using this approach, any command-line arguments to your
application are implicitly available through an args object, which is
inherited from the App trait. The args object is an instance of
Array[String], just as if you had declared a main method yourself. The
following code demonstrates how to use the args object:
The second approach to launching an application is to manually
implement a main method with the correct signature in an object, in a
manner similar to Java:

50. Functional Programming in
Scala

51. Functional Programming
• Functional programming is mainly driven by
• Functions are first class citizens. They are treated just as any other type say string, integer etc. so functions can be
used as arguments , could be defined in other functions.

52. Higher Order Functions
Functions are first class citizens.
They can be passed as a parameter and returned as a result.
Functions that take other functions as parameter or that return functions as result are called
Higher order functions.

53. Examples
1. Decorator class has a primary constructor and takes 2
arguments as a parameter right and left of type String.
2. Decorator class has a function layout within.
3. layout accepts a parameter x which is of type A ( user
defined type similar to T in java). [A] is type safety.
4. And layout returns a string which sandwiches argument
x with left and right arguments.
1. Create a method with name apply which receives 2
parameter. Function f of type int , and v of type int.
2. F is an function which receives int as an argument and
returns string as an value.
3. f : Int => String denotes function as a parameter.
4. Body of the function has f(v) which means the second
argument v is passed as an argument to the function
which was passed as an first argument.
1. Create an object to decorator class.
1. Call apply method and pass decorator.layout function as
an argument and a number 7 as a value.

54. Examples 2
This method has eliminated the need of sumInts,
sumCubes and sumSquares function.
Anonymous function has eliminated the need of other
remaining functions sum, squares and cube as well.
5 functions are created. Lets see how
we can minimize with help of higher
order functions.