![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 6
agreement, simply accept it and further it
will ask a path where Scala will be
installed. I selected default given
path “C:Program FilesScala”, you can
select a suitable path as per your
convenience.
Linux
Command −
$java –jar scala-2.9.0.1-
installer.jar
Output −
Welcome to the installation of
Scala 2.9.0.1!
The homepage is at
−http://Scala-lang.org/
press 1 to continue, 2 to quit, 3
to redisplay
1................................................
[ Starting to unpack ]
[ Processing package: Software
Package Installation (1/1) ]
[ Unpacking finished ]
[ Console installation done ]
During installation, it will ask for license
agreement, to accept it type 1 and it will
ask a path where Scala will be installed. I
entered /usr/local/share,you can select a
suitable path as per your convenience.
Finally, open a new command prompt and type Scala -version and press Enter. You should see
the following −
Platform Command Output
Windows
>scala -version
Scala code runner version 2.11.5 -- Copyright 2002-2013,
LAMP/EPFL
Linux $scala -version
Scala code runner version 2.9.0.1 – Copyright 2002-2013,
LAMP/EPFL](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-6-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 8
scala> println("Hello, Scala!");
It will produce the following result −
Hello, Scala!
Script Mode
Use the following instructions to write a Scala program in script mode. Open notepad and add
the following code into it.
Example
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
*/
def main(args: Array[String]) {
println("Hello, world!") // prints Hello World
}
}
Save the file as − HelloWorld.scala.
Open the command prompt window and go to the directory where the program file is saved.
The ‘scalac’ command is used to compile the Scala program and it will generate a few class
files in the current directory. One of them will be called HelloWorld.class. This is a bytecode
which will run on Java Virtual Machine (JVM) using ‘scala’ command.
Use the following command to compile and execute your Scala program.
> scalac HelloWorld.scala
> scala HelloWorld
Output
Hello, World!
Basic Syntax
The following are the basic syntaxes and coding conventions in Scala programming.
Case Sensitivity − Scala is case-sensitive, which means identifier Hello and hellowould
have different meaning in Scala.
Class Names − For all class names, the first letter should be in Upper Case. If several
words are used to form a name of the class, each inner word's first letter should be in
Upper Case.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-8-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 9
Example − class MyFirstScalaClass.
Method Names − All method names should start with a Lower Case letter. If multiple
words are used to form the name of the method, then each inner word's first letter should
be in Upper Case.
Example − def myMethodName()
Program File Name − Name of the program file should exactly match the object name.
When saving the file you should save it using the object name (Remember Scala is case-
sensitive) and append ‘.scala’ to the end of the name. (If the file name and the object
name do not match your program will not compile).
Example − Assume 'HelloWorld' is the object name. Then the file should be saved as
'HelloWorld.scala'.
def main(args: Array[String]) − Scala program processing starts from the main()
method which is a mandatory part of every Scala Program.
Scala Identifiers
All Scala components require names. Names used for objects, classes, variables and methods
are called identifiers. A keyword cannot be used as an identifier and identifiers are case-
sensitive. Scala supports four types of identifiers.
Alphanumeric Identifiers
An alphanumeric identifier starts with a letter or an underscore, which can be followed by
further letters, digits, or underscores. The '$' character is a reserved keyword in Scala and
should not be used in identifiers.
Following are legal alphanumeric identifiers −
age, salary, _value, __1_value
Following are illegal identifiers −
$salary, 123abc, -salary
Operator Identifiers
An operator identifier consists of one or more operator characters. Operator characters are
printable ASCII characters such as +, :, ?, ~ or #.
Following are legal operator identifiers −
+ ++ ::: <?> :>](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-9-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 11
- : = =>
<- <: <% >:
# @
Comments in Scala
Scala supports single-line and multi-line comments very similar to Java. Multi-line comments
may be nested, but are required to be properly nested. All characters available inside any
comment are ignored by Scala compiler.
object HelloWorld {
/* This is my first java program.
* This will print 'Hello World' as the output
* This is an example of multi-line comments.
*/
def main(args: Array[String]) {
// Prints Hello World
// This is also an example of single line comment.
println("Hello, world!")
}
}
Blank Lines and Whitespace
A line containing only whitespace, possibly with a comment, is known as a blank line, and
Scala totally ignores it. Tokens may be separated by whitespace characters and/or comments.
Newline Characters
Scala is a line-oriented language where statements may be terminated by semicolons (;) or
newlines. A semicolon at the end of a statement is usually optional. You can type one if you
want but you don't have to if the statement appears by itself on a single line. On the other hand,
a semicolon is required if you write multiple statements on a single line. Below syntax is the
usage of multiple statements.
val s = "hello"; println(s)
1.2 Variables and Data Types
Variables are nothing but reserved memory locations to store values. This means that when you
create a variable, you reserve some space in memory.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-11-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 12
Based on the data type of a variable, the compiler allocates memory and decides what can be
stored in the reserved memory. Therefore, by assigning different data types to variables, you
can store integers, decimals, or characters in these variables.
Variable Declaration
Scala has a different syntax for declaring variables. They can be defined as value, i.e., constant
or a variable. Here, myVar is declared using the keyword var. It is a variable that can change
value and this is called mutable variable. Following is the syntax to define a variable
using var keyword −
Syntax
var myVar : String = "Foo"
Here, myVal is declared using the keyword val. This means that it is a variable that cannot be
changed and this is called immutable variable. Following is the syntax to define a variable
using val keyword −
Syntax
val myVal : String = "Foo"
Variable Data Types
The type of a variable is specified after the variable name and before equals sign. You can
define any type of Scala variable by mentioning its data type as follows −
Syntax
val or val VariableName : DataType = [Initial Value]
If you do not assign any initial value to a variable, then it is valid as follows −
Syntax
var myVar :Int;
val myVal :String;
Variable Type Inference
When you assign an initial value to a variable, the Scala compiler can figure out the type of the
variable based on the value assigned to it. This is called variable type inference. Therefore, you
could write these variable declarations like this −
Syntax](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-12-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 13
var myVar = 10;
val myVal = "Hello, Scala!";
Here, by default, myVar will be Int type and myVal will become String type variable.
Multiple assignments
Scala supports multiple assignments. If a code block or method returns a Tuple (Tuple − Holds
collection of Objects of different types), the Tuple can be assigned to a val variable. [Note − We
will study Tuples in subsequent chapters.]
Syntax
val (myVar1: Int, myVar2: String) = Pair(40, "Foo")
And the type inference gets it right −
Syntax
val (myVar1, myVar2) = Pair(40, "Foo")
Example Program
The following is an example program that explains the process of variable declaration in Scala.
This program declares four variables — two variables are defined with type declaration and
remaining two are without type declaration.
Example
object Demo {
def main(args: Array[String]) {
var myVar :Int = 10;
val myVal :String = "Hello Scala with datatype declaration.";
var myVar1 = 20;
val myVal1 = "Hello Scala new without datatype declaration.";
println(myVar); println(myVal); println(myVar1);
println(myVal1);
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-13-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 18
The null value is of type scala.Null and is thus compatible with every reference type. It denotes
a reference value which refers to a special "null" object.
Escape Sequences
The following escape sequences are recognized in character and string literals.
Escape Sequences Unicode Description
b u0008 backspace BS
t u0009 horizontal tab HT
n u000c formfeed FF
f u000c formfeed FF
r u000d carriage return CR
" u0022 double quote "
' u0027 single quote .
u005c backslash
A character with Unicode between 0 and 255 may also be represented by an octal escape, i.e., a
backslash '' followed by a sequence of up to three octal characters. Following is the example to
show few escape sequence characters −
Example
object Test {
def main(args: Array[String]) {
println("HellotWorldnn" );
}
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-18-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 24
&= Bitwise AND assignment operator C &= 2 is same as C = C & 2
^= bitwise exclusive OR and assignment operator C ^= 2 is same as C = C ^ 2
|= bitwise inclusive OR and assignment operator C |= 2 is same as C = C | 2
Operators Precedence in Scala
Operator precedence determines the grouping of terms in an expression. This affects how an
expression is evaluated. Certain operators have higher precedence than others; for example, the
multiplication operator has higher precedence than the addition operator −
For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher
precedence than +, so it first gets multiplied with 3*2 and then adds into 7.
Take a look at the following table. Operators with the highest precedence appear at the top of
the table and those with the lowest precedence appear at the bottom. Within an expression,
higher precedence operators will be evaluated first.
Category Operator Associativity
Postfix () [] Left to right
Unary ! ~ Right to left
Multiplicative * / % Left to right
Additive + - Left to right
Shift >> >>> << Left to right
Relational > >= < <= Left to right
Equality == != Left to right](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-24-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 29
Basic Class
class Student{
var id:Int = 0; // All fields must be initialized
var name:String = null;
}
object MainObject{
def main(args:Array[String]){
var s = new Student() // Creating an object
println(s.id+" "+s.name);
}
}
Output:
0 null
Scala Sample Example2 of Class
In scala, you can create class like this also. Here, constructor is created in class definition. This is
called primary constructor.
class Student(id:Int, name:String){ // Primary constructor
def show(){
println(id+" "+name)
}
}
object MainObject{
def main(args:Array[String]){
var s = new Student(100,"Martin") // Passing values to constructor
s.show() // Calling a function by using an object
}
}
Output:
100 Martin
Scala Example of class that maintains the records of students
class Student(id:Int, name:String){
def getRecord(){
println(id+" "+name);
}
}
object MainObject{
def main(args: Array[String]){
var student1 = new Student(101,"Raju");
var student2 = new Student(102,"Martin");
student1.getRecord();](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-29-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 30
student2.getRecord();
}
}
Output:
101 Raju
102 Martin
Scala Anonymous object
In scala, you can create anonymous object. An object which has no reference name is called
anonymous object. It is good to create anonymous object when you don't want to reuse it further.
Scala Anonymous object Example
class Arithmetic{
def add(a:Int, b:Int){
var add = a+b;
println("sum = "+add);
}
}
object MainObject{
def main(args:Array[String]){
new Arithmetic().add(10,10);
}
}
Output:
Sum = 20
Object
Object is a real world entity. It contains state and behavior. Laptop, car, cell phone are the real
world objects. Object typically has two characteristics:
1) State: data values of an object are known as its state.
2) Behavior: functionality that an object performs is known as its behavior.
Object in scala is an instance of class. It is also known as runtime entity.
1.7 Control statements and Looping Statements
Scala provides if statement to test the conditional expressions. It tests boolean conditional
expression which can be either true or false. Scala use various types of if else statements.
If statement
If-else statement](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-30-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 31
Nested if-else statement
If-else-if ladder statement
if Statement
‘if’ statement consists of a Boolean expression followed by one or more statements.
Syntax
The syntax of an ‘if’ statement is as follows.
if(Boolean_expression) {
// Statements will execute if the Boolean expression is true
}
If the Boolean expression evaluates to true then the block of code inside the ‘if’ expression will
be executed. If not, the first set of code after the end of the ‘if’ expression (after the closing
curly brace) will be executed.
Try the following example program to understand conditional expressions (if expression) in
Scala Programming Language.
Example
object Demo {
def main(args: Array[String]) {
var x = 10;
if( x < 20 ){
println("This is if statement");
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
This is if statement](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-31-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 32
If-else Statement
An ‘if’ statement can be followed by an optional else statement, which executes when the
Boolean expression is false.
Syntax
The syntax of a if...else is −
if(Boolean_expression){
//Executes when the Boolean expression is true
} else{
//Executes when the Boolean expression is false
}
Try the following example program to understand conditional statements (if- else statement) in
Scala Programming Language.
Example
object Demo {
def main(args: Array[String]) {
var x = 30;
if( x < 20 ){
println("This is if statement");
} else {
println("This is else statement");
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
This is else statement
Nested if-else Statement](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-32-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 33
It is always legal to nest if-else statements, which means you can use one if or else-ifstatement
inside another if or else-if statement.
Syntax
The syntax for a nested if-else is as follows −
if(Boolean_expression 1){
//Executes when the Boolean expression 1 is true
if(Boolean_expression 2){
//Executes when the Boolean expression 2 is true
}
}
Try the following example program to understand conditional statements (nested- if statement)
in Scala Programming Language.
Example
object Demo {
def main(args: Array[String]) {
var x = 30;
var y = 10;
if( x == 30 ){
if( y == 10 ){
println("X = 30 and Y = 10");
}
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
X = 30 and Y = 10](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-33-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 36
immediately following the loop.
The infinite Loop
A loop becomes an infinite loop if a condition never becomes false. If you are using Scala, the
while loop is the best way to implement infinite loop.
Example
object Demo {
def main(args: Array[String]) {
var a = 10;
// An infinite loop.
while( true ){
println( "Value of a: " + a );
}
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
If you will execute above code, it will go in infinite loop which you can terminate by pressing
Ctrl + C keys.
Value of a: 10
Value of a: 10
Value of a: 10
Value of a: 10
while loop Example
object MainObject {
def main(args: Array[String]) {
var a = 10; // Initialization
while( a<=20 ){ // Condition
println(a);
a = a+2 // Incrementation
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-36-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 37
}
}
do-while loop example
object MainObject {
def main(args: Array[String]) {
var a = 10; // Initialization
do {
println( a );
a = a + 2; // Increment
}
while( a <= 20 ) // Condition
}
}
for loop
In scala, for loop is known as for-comprehensions. It can be used to iterate, filter and return an
iterated collection. The for-comprehension looks a bit like a for-loop in imperative languages,
except that it constructs a list of the results of all iterations.
Syntax
for( i <- range){
// statements to be executed
}
In the above syntax, range is a value which has start and end point. You can pass range by using
to or until keyword.
Scala for-loop example by using to keyword
object MainObject {
def main(args: Array[String]) {
for( a <- 1 to 10 ){
println(a);
}
}
}
The major difference between until and to is, to includes start and end value given in the range,
while until excludes last value of the range. So, the below example will print only 1 to 9.
Scala for-loop Example by using until keyword
object MainObject {
def main(args: Array[String]) {
for( a <- 1 until 10 ){
println(a);
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-37-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 38
}
}
for-loop filtering Example
You can use for to filter your data. In the below example, we are filtering our data by passing a
conditional expression. This program prints only even values in the given range.
object MainObject {
def main(args: Array[String]) {
for( a <- 1 to 10 if a%2==0 ){
println(a);
}
}
}
for-loop Example by using yield keyword
In the above example, we have used yield keyword which returns a result after completing of
loop iterations. The for use buffer internally to store iterated result and after finishing all
iterations it yields the final result from that buffer. It does not work like imperative loop.
object MainObject {
def main(args: Array[String]) {
var result = for( a <- 1 to 10) yield a
for(i<-result){
println(i)
}
}
}
for-loop Example using by keyword
In the above example, we have used by keyword. The by keyword is used to skip the iteration.
When you code like: by 2 it means, this loop will skip all even iterations of loop.
object MainObject {
def main(args: Array[String]) {
for(i<-1 to 10 by 2){
println(i)
}
}
}
1.8 Strings](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-38-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 39
String is a combination of characters or we can say it is a sequence of characters. It is index
based data structure and use linear approach to store data into memory. String is immutable in
scala like java. You can manipulate string and can apply method to get desire result but you can't
change original string object.
Creating a String
The following code can be used to create a String −
var greeting = "Hello world!";
or
var greeting:String = "Hello world!";
Whenever compiler encounters a string literal in the code, it creates a String object with its
value, in this case, “Hello world!”. String keyword can also be given in alternate declaration as
shown above.
Try the following example program.
Example
object Demo {
val greeting: String = "Hello, world!"
def main(args: Array[String]) {
println( greeting )
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
Hello, world!
As mentioned earlier, String class is immutable. String object once created cannot be changed.
If there is a necessity to make a lot of modifications to Strings of characters then use String
Builder Class available in Scala!.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-39-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 40
String Length
Methods used to obtain information about an object are known as accessor methods. One
accessor method that can be used with strings is the length() method, which returns the number
of characters contained in the string object.
Use the following code segment to find the length of a string −
Example
object Demo {
def main(args: Array[String]) {
var palindrome = "Dot saw I was Tod";
var len = palindrome.length();
println( "String Length is : " + len );
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
String Length is : 17
Concatenating Strings
The String class includes a method for concatenating two strings −
string1.concat(string2);
This returns a new string that is string1 with string2 added to it at the end. You can also use the
concat() method with string literals, as in −
"My name is ".concat("Zara");
Strings are more commonly concatenated with the + operator, as in −
"Hello," + " world" + "!"
Which results in −
"Hello, world!"](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-40-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 41
The following lines of code to find string length.
Example
object Demo {
def main(args: Array[String]) {
var str1 = "Dot saw I was ";
var str2 = "Tod";
println("Dot " + str1 + str2);
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
Dot Dot saw I was Tod
Creating Format Strings
You have printf() and format() methods to print output with formatted numbers. The String
class has an equivalent class method, format(), that returns a String object rather than a
PrintStream object.
Try the following example program, which makes use of printf() method −
Example
object Demo {
def main(args: Array[String]) {
var floatVar = 12.456
var intVar = 2000
var stringVar = "Hello, Scala!"
var fs = printf("The value of the float variable is " + "%f, while the value of the integer " +
"variable is %d, and the string" + "is %s", floatVar, intVar, stringVar);
println(fs)](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-41-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 43
object Demo {
def main(args: Array[String]) {
val name = "James"
println(s"Hello, $name")
println(s"1 + 1 = ${1 + 1}")
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
Hello, James
1 + 1 = 2
The ‘ f ’ Interpolator
The literal ‘f’ interpolator allows to create a formatted String, similar to printf in C language.
While using ‘f’ interpolator, all variable references should be followed by the printf style
format specifiers such as %d, %i, %f, etc.
Let us take an example of append floating point value (height = 1.9d) and String variable (name
= “James”) with normal string. The following code snippet of implementing ‘f’ Interpolator.
Here $name%s to print (String variable) James and $height%2.2f to print (floating point value)
1.90.
val height = 1.9d
val name = "James"
println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall
It is type safe (i.e.) the variable reference and following format specifier should match otherwise
it is showing error. The ‘ f ’ interpolator makes use of the String format utilities (format
specifiers) available in Java. By default means, there is no % character after variable reference.
It will assume as %s (String).
‘raw’ Interpolator
The ‘raw’ interpolator is similar to ‘s’ interpolator except that it performs no escaping of literals
within a string. The following code snippets in a table will differ the usage of ‘s’ and ‘raw’](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-43-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 44
interpolators. In outputs of ‘s’ usage ‘n’ effects as new line and in output of ‘raw’ usage the ‘n’
will not effect. It will print the complete string with escape letters.
‘s’ interpolator usage ‘raw’ interpolator usage
Program −
object Demo {
def main(args: Array[String]) {
println(s"Result = n a n b")
}
}
Program −
object Demo {
def main(args: Array[String]) {
println(raw"Result = n a n b")
}
}
Output −
Result =
a
b
String Methods
S.No Methods with Description
1 char charAt(int index)
Returns the character at the specified index.
2 int compareTo(Object o)
Compares this String to another Object.
3 int compareTo(String anotherString)
Compares two strings lexicographically.
4 int compareToIgnoreCase(String str)
Compares two strings lexicographically, ignoring case differences.
5 String concat(String str)
Concatenates the specified string to the end of this string.
6 boolean contentEquals(StringBuffer sb)
Returns true if and only if this String represents the same sequence of characters as the
specified StringBuffer.
7 static String copyValueOf(char[] data)
Returns a String that represents the character sequence in the array specified.
8 static String copyValueOf(char[] data, int offset, int count)
Returns a String that represents the character sequence in the array specified.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-44-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 45
9 boolean endsWith(String suffix)
Tests if this string ends with the specified suffix.
10 boolean equals(Object anObject)
Compares this string to the specified object.
11 boolean equalsIgnoreCase(String anotherString)
Compares this String to another String, ignoring case considerations.
12 byte getBytes()
Encodes this String into a sequence of bytes using the platform's default charset, storing the
result into a new byte array.
13 byte[] getBytes(String charsetName)
Encodes this String into a sequence of bytes using the named charset, storing the result into a
new byte array.
14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)
Copies characters from this string into the destination character array.
15 int hashCode()
Returns a hash code for this string.
16 int indexOf(int ch)
Returns the index within this string of the first occurrence of the specified character.
17 int indexOf(int ch, int fromIndex)
Returns the index within this string of the first occurrence of the specified character, starting
the search at the specified index.
18 int indexOf(String str)
Returns the index within this string of the first occurrence of the specified substring.
19 int indexOf(String str, int fromIndex)
Returns the index within this string of the first occurrence of the specified substring, starting
at the specified index.
20 String intern()
Returns a canonical representation for the string object.
21 int lastIndexOf(int ch)
Returns the index within this string of the last occurrence of the specified character.
22 int lastIndexOf(int ch, int fromIndex)
Returns the index within this string of the last occurrence of the specified character,
searching backward starting at the specified index.
23 int lastIndexOf(String str)
Returns the index within this string of the rightmost occurrence of the specified substring.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-45-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 46
24 int lastIndexOf(String str, int fromIndex)
Returns the index within this string of the last occurrence of the specified substring,
searching backward starting at the specified index.
25 int length()
Returns the length of this string.
26 boolean matches(String regex)
Tells whether or not this string matches the given regular expression.
27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len)
Tests if two string regions are equal.
28 boolean regionMatches(int toffset, String other, int offset, int len)
Tests if two string regions are equal.
29 String replace(char oldChar, char newChar)
Returns a new string resulting from replacing all occurrences of oldChar in this string with
newChar.
30 String replaceAll(String regex, String replacement
Replaces each substring of this string that matches the given regular expression with the
given replacement.
31 String replaceFirst(String regex, String replacement)
Replaces the first substring of this string that matches the given regular expression with the
given replacement.
32 String[] split(String regex)
Splits this string around matches of the given regular expression.
33 String[] split(String regex, int limit)
Splits this string around matches of the given regular expression.
34 boolean startsWith(String prefix)
Tests if this string starts with the specified prefix.
35 boolean startsWith(String prefix, int toffset)
Tests if this string starts with the specified prefix beginning a specified index.
36 CharSequence subSequence(int beginIndex, int endIndex)
Returns a new character sequence that is a subsequence of this sequence.
37 String substring(int beginIndex)
Returns a new string that is a substring of this string.
38 String substring(int beginIndex, int endIndex)
Returns a new string that is a substring of this string.
39 char[] toCharArray()](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-46-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 47
Converts this string to a new character array.
40 String toLowerCase()
Converts all of the characters in this String to lower case using the rules of the default locale.
41 String toLowerCase(Locale locale)
Converts all of the characters in this String to lower case using the rules of the given Locale.
42 String toString()
This object (which is already a string!) is itself returned.
43 String toUpperCase()
Converts all of the characters in this String to upper case using the rules of the default locale.
44 String toUpperCase(Locale locale)
Converts all of the characters in this String to upper case using the rules of the given Locale.
45 String trim()
Returns a copy of the string, with leading and trailing whitespace omitted.
46 static String valueOf(primitive data type x)
Returns the string representation of the passed data type argument.
Example
class StringExample{
var s1 = "Scala string example"
var s2 = "Hello Scala"
var s3 = "Hello Scala"
def show(){
println(s1.equals(s2))
println(s2.equals(s3))
}
}
object MainObject{
def main(args:Array[String]){
var s = new StringExample()
s.show()
}
}
1.9 Arrays
Array is a collection of mutable values. It is an index based data structure which starts
from 0 index to n-1 where n is length of array.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-47-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 48
Scala arrays can be generic. It means, you can have an Array[T], where T is a type
parameter or abstract type. Scala arrays are compatible with Scala sequences - you can
pass an Array[T] where a Seq[T] is required. It also supports all the sequence operations.
Following image represents the structure of array where first index is 0, last index is 9 and array
length is 10.
Types of array
Single dimensional array
Multidimensional array
Single Dimensional Array
Single dimensional array is used to store elements in linear order. Array elements are stored in
contiguous memory space. So, if you have any index of an array, you can easily traverse all the
elements of the array.
Syntax for Single Dimensional Array
var arrayName : Array[arrayType] = new Array[arrayType](arraySize); or
var arrayName = new Array[arrayType](arraySize) or
var arrayName : Array[arrayType] = new Array(arraySize); or
var arrayName = Array(element1, element2 ... elementN)
Array Example: Single Dimensional
class ArrayExample{
var arr = Array(1,2,3,4,5) // Creating single dimensional array
def show(){
for(a<-arr) // Traversing array elements
println(a)
println("Third Element = "+ arr(2)) // Accessing elements by using index
}
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-48-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 49
object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:
1
2
3
4
5
Third Element = 3
Example 2: Single Dimensional
In this example, we have created an array by using new keyword which is used to initialize
memory for array. The entire array elements are set to default value, you can assign that later in
your code.
class ArrayExample{
var arr = new Array[Int](5) // Creating single dimensional array
def show(){
for(a<-arr){ // Traversing array elements
println(a)
}
println("Third Element before assignment = "+ arr(2)) // Accessing elements by using
index
arr(2) = 10 // Assigning new element at 2 index
println("Third Element after assignment = "+ arr(2))
}
}
object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:
0](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-49-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 50
0
0
0
0
Third Element before assignment = 0
Third Element after assignment = 10
Scala Passing Array into Function
You can pass array as an argument to function during function call. Following example illustrate
the process how we can pass an array to the function.
class ArrayExample{
def show(arr:Array[Int]){
for(a<-arr) // Traversing array elements
println(a)
println("Third Element = "+ arr(2)) // Accessing elements by using index
}
}
object MainObject{
def main(args:Array[String]){
var arr = Array(1,2,3,4,5,6) // creating single dimensional array
var a = new ArrayExample()
a.show(arr) // passing array as an argument in the function
}
}
Output:
1
2
3
4
5
6
Third Element = 3
Array Example: Iterating By using Foreach Loop
You can also iterate array elements by using foreach loop. Let's see an example.
class ArrayExample{
var arr = Array(1,2,3,4,5) // Creating single dimensional array
arr.foreach((element:Int)=>println(element)) // Iterating by using foreach loop
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-50-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 51
object MainObject{
def main(args:Array[String]){
new ArrayExample()
}
}
Output:
1
2
3
4
5
Multidimensional Array
Multidimensional array is an array which store data in matrix form. You can create from two
dimensional to three, four and many more dimensional array according to your need. Below we
have mentioned array syntax. Scala provides an ofDim method to create multidimensional array.
Multidimensional Array Syntax
var arrayName = Array.ofDim[ArrayType](NoOfRows,NoOfColumns) or
var arrayName = Array(Array(element...), Array(element...), ...)
Scala Multidimensional Array Example by using ofDim
In This example, we have created array by using ofDim method.
class ArrayExample{
var arr = Array.ofDim[Int](2,2) // Creating multidimensional array
arr(1)(0) = 15 // Assigning value
def show(){
for(i<- 0 to 1){ // Traversing elements by using loop
for(j<- 0 to 1){
print(" "+arr(i)(j))
}
println()
}
println("Third Element = "+ arr(1)(1)) // Accessing elements by using index
}
}
object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-51-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 52
}
}
Output:
0 0
15 0
Third Element = 0
Scala Multidimensional Array by using Array of Array
Apart from ofDim you can also create multidimensional array by using array of array. In this
example, we have created multidimensional array by using array of array.
class ArrayExample{
var arr = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) // Creating multidimensional array
def show(){
for(i<- 0 to 1){ // Traversing elements using loop
for(j<- 0 to 4){
print(" "+arr(i)(j))
}
println()
}
}
}
object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:
1 2 3 4 5
6 7 8 9 10
Scala Addition of Two Matrix Example
You can manipulate array elements in scala. Here, we are adding two array elements and storing
result into third array.
class ArrayExample{
var arr1 = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) // Creating multidimensional array
var arr2 = Array(Array(1,2,3,4,5), Array(6,7,8,9,10))
var arr3 = Array.ofDim[Int](2,5)](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-52-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 53
def show(){
for(i<- 0 to 1){ // Traversing elements using loop
for(j<- 0 to 4){
arr3(i)(j) = arr1(i)(j)+arr2(i)(j)
print(" "+arr3(i)(j))
}
println()
}
}
}
object MainObject{
def main(args:Array[String]){
var a = new ArrayExample()
a.show()
}
}
Output:
2 4 6 8 10
12 14 16 18 20
1.10 Functions
A function is a group of statements that perform a task. You can divide up your code
into separate functions. How you divide up your code among different functions is up to
you, but logically, the division usually is so that each function performs a specific task.
Scala has both functions and methods and we use the terms method and function
interchangeably with a minor difference. A Scala method is a part of a class which has a
name, a signature, optionally some annotations, and some bytecode where as a function
in Scala is a complete object which can be assigned to a variable. In other words, a
function, which is defined as a member of some object, is called a method.
A function definition can appear anywhere in a source file and Scala permits nested
function definitions, that is, function definitions inside other function definitions. Most
important point to note is that Scala function's name can have characters like +, ++, ~,
&,-, --, , /, :, etc.
Function Declarations
A Scala function declaration has the following form −
def functionName ([list of parameters]) : [return type]
Methods are implicitly declared abstract if you don’t use the equals sign and the method body.](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-53-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 54
Function Definitions
A Scala function definition has the following form −
Syntax
def functionName ([list of parameters]) : [return type] = {
function body
return [expr]
}
Here, return type could be any valid Scala data type and list of parameters will be a list of
variables separated by comma and list of parameters and return type are optional. Very similar
to Java, a return statement can be used along with an expression in case function returns a
value. Following is the function which will add two integers and return their sum −
Syntax
object add {
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
A function, that does not return anything can return a Unit that is equivalent to void in Java and
indicates that function does not return anything. The functions which do not return anything in
Scala, they are called procedures.
Syntax
Here is the syntax −
object Hello{
def printMe( ) : Unit = {
println("Hello, Scala!")
}
}
Calling Functions
Scala provides a number of syntactic variations for invoking methods. Following is the standard
way to call a method −
functionName( list of parameters )](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-54-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 55
Example
object Demo {
def main(args: Array[String]) {
println( "Returned Value : " + addInt(5,7) );
}
def addInt( a:Int, b:Int ) : Int = {
var sum:Int = 0
sum = a + b
return sum
}
}
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
Returned Value : 12
1.10.1 Higher-Order Functions
Scala allows the definition of higher-order functions. These are functions that take other
functions as parameters, or whose result is a function.
Try the following example program, apply() function takes another function f and a value v and
applies function f to v.
Example
object Demo {
def main(args: Array[String]) {
println( apply( layout, 10) )
}
def apply(f: Int => String, v: Int) = f(v)
def layout[A](x: A) = "[" + x.toString() + "]"
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-55-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 56
Save the above program in Demo.scala. The following commands are used to compile and
execute this program.
Command
>scalac Demo.scala
>scala Demo
Output
[10]
1.10.2 Function Composition
In scala, functions can be composed from other functions. It is a process of composing in which
a function represents the application of two composed functions.
Let's see an example.
object MainObject {
def main(args: Array[String]) = {
var result = multiplyBy2(add2(10)) // Function composition
println(result)
}
def add2(a:Int):Int = {
a+2
}
def multiplyBy2(a:Int):Int = {
a*2
}
}
Output:
24
1.10.3 Scala Anonymous (lambda) Function
Anonymous function is a function that has no name but works as a function. It is good to create
an anonymous function when you don't want to reuse it latter.
You can create anonymous function either by using => (rocket) or _ (underscore) wild card in
scala.
Let's see an example.
Scala Anonymous function Example](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-56-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 57
object MainObject {
def main(args: Array[String]) = {
var result1 = (a:Int, b:Int) => a+b // Anonymous function by using => (rocket)
var result2 = (_:Int)+(_:Int) // Anonymous function by using _ (underscore) wild card
println(result1(10,10))
println(result2(10,10))
}
}
Output:
20
20
1.10.4 Scala Multiline Expression
Expressions those are written in multiple lines are called multiline expression. In scala, be
carefull while using multiline expressions.
The following program explains about if we break an expression into multiline, the scala
compiler throw a warning message.
Scala Multiline Expression Example
def add1(a:Int, b:Int) = {
a
+b
}
The above program does not evaluate complete expression and just return b here. So, be careful
while using multiline expressions.
Output:
MainObject.scala:3: warning: a pure expression does nothing in statement
position; you may be omitting necessary parentheses
a
^
one warning found
10
You can apply following ways to avoid above problem.
Scala Example Multiline Expression](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-57-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 58
object MainObject {
def add2(a:Int, b:Int) = {
a+
b
}
def add3(a:Int, b:Int) = {
(a
+b)
}
def main(args: Array[String]) = {
var result2 = add2(10,10)
var result3 = add3(10,10)
println(result2+"n"+result3)
}
}
Output:
20
20
1.10.5 Function Currying
In scala, method may have multiple parameter lists. When a method is called with a
fewer number of parameter lists, then this will yield a function taking the missing
parameter lists as its arguments.
In other words it is a technique of transforming a function that takes multiple arguments
into a function that takes a single argument.
Scala Function Currying Example
object MainObject {
def add(a:Int)(b:Int) = {
a+b
}
def main(args: Array[String]) = {
var result = add(10)(10)
println("10 + 10 = "+result)
var addIt = add(10)_
var result2 = addIt(3)
println("10 + 3 = "+result2)
}
}
Output:
20](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-58-320.jpg)
![Easwari Engineering College
191AIC302T-Object Oriented Programming with SCALA
Unit-I
Department of AI & DSPage 60
Now factor has a reference to a variable outside the function but in the enclosing scope. The
function references factor and reads its current value each time. If a function has no external
references, then it is trivially closed over itself. No external context is required.
Example
object Demo {
def main(args: Array[String]) {
println( "multiplier(1) value = " + multiplier(1) )
println( "multiplier(2) value = " + multiplier(2) )
}
var factor = 3
val multiplier = (i:Int) => i * factor
}](https://image.slidesharecdn.com/unit1notes-230111081302-d4cf478e/85/Unit-1-notes-pdf-60-320.jpg)
Unit 1 notes.pdf
- 1. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 1 UNIT I: Basics of Scala 9 Introduction - The Scala Environment – Data types – Variables – Operators - Expressions, Values, and Types – Names – Classes and objects - Control statements and Looping Statements – Strings – Arrays – Functions - Higher-Order Functions - Curried Functions - Higher-Order Functions on Lists – Closures. 1.1 Introduction: Scala is a general-purpose programming language. It supports object oriented, functional and imperative programming approaches. It is a strong static type language. In scala, everything is an object whether it is a function or a number. It does not have concept of primitive data. It was designed by Martin Odersky. It was officially released for java platform in early 2004 and for .Net framework in June 2004. Later on, Scala dropped .Net support in 2012. Scala is influenced by Java, Haskell, Lisp, Pizza etc. and influenced to F#, Fantom, Red etc. File extension of scala source file may be either .scala or .sc. Applications like web application, enterprise application, mobile application, desktop based application etc. Features of Scala There are following features of scala: o Type inference o Singleton object o Immutability o Lazy computation o Case classes and Pattern matching o Concurrency control o String interpolation o Higher order function o Traits o Rich collection set
- 2. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 2 Type Inference In Scala, you don't require to mention data type and function return type explicitly. Scala is enough smart to deduce the type of data. The return type of function is determined by the type of last expression present in the function. Singleton object In Scala, there are no static variables or methods. Scala uses singleton object, which is essentially class with only one object in the source file. Singleton object is declared by using object instead of class keyword. Immutability Scala uses immutability concept. Each declared variable is immutable by default. Immutable means you can't modify its value. You can also create mutable variables which can be changed.Immutable data helps to manage concurrency control which requires managing data. Lazy Computation In Scala, computation is lazy by default. Scala evaluates expressions only when they are required. You can declare a lazy variable by using lazy keyword. It is used to increase performance. Case classes and Pattern matching Scala case classes are just regular classes which are immutable by default and decomposable through pattern matching. All the parameters listed in the case class are public and immutable by default. Case classes support pattern matching. So, you can write more logical code. Concurrency control Scala provides standard library which includes the actor model. You can write concurrency code by using actor. Scala provides one more platform and tool to deal with
- 3. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 3 concurrency known as Akka. Akka is a separate open source framework that provides actor-based concurrency. Akka actors may be distributed or combined with software transactional memory. String Interpolation Since Scala 2.10.0, Scala offers a new mechanism to create strings from your data. It is called string interpolation. String interpolation allows users to embed variable references directly in processed string literals. Scala provides three string interpolation methods: s, f and raw. Higher Order Functions Higher order function is a function that either takes a function as argument or returns a function. In other words, we can say a function which works with another function is called higher order function. Higher order function allows you to create function composition, lambda function or anonymous function etc. Traits A trait is like an interface with a partial implementation. In Scala, trait is a collection of abstract and non-abstract methods. You can create trait that can have all abstract methods or some abstract and some non-abstract methods. Traits are compiled into Java interfaces with corresponding implementation classes that hold any methods implemented in the traits. Rich Set of Collection Scala provides rich set of collection library. It contains classes and traits to collect data. These collections can be mutable or immutable. You can use it according to your requirement. Scala.collection.mutable package contains all the mutable collections. You can add, remove and update data while using this package. Scala.collection.immutable package contains all the immutable collections. It does not allow you to modify data.
- 4. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 4 1.2 The Scala Environment Scala can be installed on any UNIX flavored or Windows based system. Before you start installing Scala on your machine, you must have Java 1.8 or greater installed on your computer. Follow the steps given below to install Scala. Step 1: Verify Your Java Installation First of all, you need to have Java Software Development Kit (SDK) installed on your system. To verify this, execute any of the following two commands depending on the platform you are working on. If the Java installation has been done properly, then it will display the current version and specification of your Java installation. A sample output is given in the following table. Platform Command Sample Output Windows Open Command Console and type − >java –version Java version "1.8.0_31" Java (TM) SE Run Time Environment (build 1.8.0_31-b31) Java Hotspot (TM) 64-bit Server VM (build 25.31-b07, mixed mode) Linux Open Command terminal and type − $java –version Java version "1.8.0_31" Open JDK Runtime Environment (rhel- 2.8.10.4.el6_4-x86_64) Open JDK 64-Bit Server VM (build 25.31-b07, mixed mode) We assume that the readers of this tutorial have Java SDK version 1.8.0_31 installed on their system. In case you do not have Java SDK, download its current version fromhttp://www.oracle.com/technetwork/java/javase/downloads/index.html and install it. Step 2: Set Your Java Environment
- 5. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 5 Set the environment variable JAVA_HOME to point to the base directory location where Java is installed on your machine. For example, Sr.No Platform & Description 1 Windows Set JAVA_HOME to C:ProgramFilesjavajdk1.7.0_60 2 Linux Export JAVA_HOME=/usr/local/java-current Append the full path of Java compiler location to the System Path. Sr.No Platform & Description 1 Windows Append the String "C:Program FilesJavajdk1.7.0_60bin" to the end of the system variable PATH. 2 Linux Export PATH=$PATH:$JAVA_HOME/bin/ Execute the command java -version from the command prompt as explained above. Step 3: Install Scala You can download Scala from http://www.scala-lang.org/downloads. At the time of writing this tutorial, I downloaded ‘scala-2.11.5-installer.jar’. Make sure you have admin privilege to proceed. Now, execute the following command at the command prompt − Platform Command & Output Description Windows >java –jar scala-2.11.5- installer.jar> This command will display an installation wizard, which will guide you to install Scala on your windows machine. During installation, it will ask for license
- 6. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 6 agreement, simply accept it and further it will ask a path where Scala will be installed. I selected default given path “C:Program FilesScala”, you can select a suitable path as per your convenience. Linux Command − $java –jar scala-2.9.0.1- installer.jar Output − Welcome to the installation of Scala 2.9.0.1! The homepage is at −http://Scala-lang.org/ press 1 to continue, 2 to quit, 3 to redisplay 1................................................ [ Starting to unpack ] [ Processing package: Software Package Installation (1/1) ] [ Unpacking finished ] [ Console installation done ] During installation, it will ask for license agreement, to accept it type 1 and it will ask a path where Scala will be installed. I entered /usr/local/share,you can select a suitable path as per your convenience. Finally, open a new command prompt and type Scala -version and press Enter. You should see the following − Platform Command Output Windows >scala -version Scala code runner version 2.11.5 -- Copyright 2002-2013, LAMP/EPFL Linux $scala -version Scala code runner version 2.9.0.1 – Copyright 2002-2013, LAMP/EPFL
- 7. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 7 Basic Syntax: In a Scala program, it can be defined as a collection of objects that communicate via invoking each other’s methods. Let us now briefly look into what do class, object, methods and instance variables mean. Object − Objects have states and behaviors. An object is an instance of a class. Example − A dog has states - color, name, breed as well as behaviors - wagging, barking, and eating. Class − A class can be defined as a template/blueprint that describes the behaviors/states that are related to the class. Methods − A method is basically a behavior. A class can contain many methods. It is in methods where the logics are written, data is manipulated and all the actions are executed. Fields − Each object has its unique set of instance variables, which are called fields. An object's state is created by the values assigned to these fields. Closure − A closure is a function, whose return value depends on the value of one or more variables declared outside this function. Traits − A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Traits are used to define object types by specifying the signature of the supported methods. First Scala Program We can execute a Scala program in two modes: one is interactive mode and another isscript mode. Interactive Mode Open the command prompt and use the following command to open Scala. >scala If Scala is installed in your system, the following output will be displayed − Welcome to Scala version 2.9.0.1 Type in expressions to have them evaluated. Type :help for more information. Type the following text to the right of the Scala prompt and press the Enter key −
- 8. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 8 scala> println("Hello, Scala!"); It will produce the following result − Hello, Scala! Script Mode Use the following instructions to write a Scala program in script mode. Open notepad and add the following code into it. Example object HelloWorld { /* This is my first java program. * This will print 'Hello World' as the output */ def main(args: Array[String]) { println("Hello, world!") // prints Hello World } } Save the file as − HelloWorld.scala. Open the command prompt window and go to the directory where the program file is saved. The ‘scalac’ command is used to compile the Scala program and it will generate a few class files in the current directory. One of them will be called HelloWorld.class. This is a bytecode which will run on Java Virtual Machine (JVM) using ‘scala’ command. Use the following command to compile and execute your Scala program. > scalac HelloWorld.scala > scala HelloWorld Output Hello, World! Basic Syntax The following are the basic syntaxes and coding conventions in Scala programming. Case Sensitivity − Scala is case-sensitive, which means identifier Hello and hellowould have different meaning in Scala. Class Names − For all class names, the first letter should be in Upper Case. If several words are used to form a name of the class, each inner word's first letter should be in Upper Case.
- 9. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 9 Example − class MyFirstScalaClass. Method Names − All method names should start with a Lower Case letter. If multiple words are used to form the name of the method, then each inner word's first letter should be in Upper Case. Example − def myMethodName() Program File Name − Name of the program file should exactly match the object name. When saving the file you should save it using the object name (Remember Scala is case- sensitive) and append ‘.scala’ to the end of the name. (If the file name and the object name do not match your program will not compile). Example − Assume 'HelloWorld' is the object name. Then the file should be saved as 'HelloWorld.scala'. def main(args: Array[String]) − Scala program processing starts from the main() method which is a mandatory part of every Scala Program. Scala Identifiers All Scala components require names. Names used for objects, classes, variables and methods are called identifiers. A keyword cannot be used as an identifier and identifiers are case- sensitive. Scala supports four types of identifiers. Alphanumeric Identifiers An alphanumeric identifier starts with a letter or an underscore, which can be followed by further letters, digits, or underscores. The '$' character is a reserved keyword in Scala and should not be used in identifiers. Following are legal alphanumeric identifiers − age, salary, _value, __1_value Following are illegal identifiers − $salary, 123abc, -salary Operator Identifiers An operator identifier consists of one or more operator characters. Operator characters are printable ASCII characters such as +, :, ?, ~ or #. Following are legal operator identifiers − + ++ ::: <?> :>
- 10. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 10 The Scala compiler will internally "mangle" operator identifiers to turn them into legal Java identifiers with embedded $ characters. For instance, the identifier :-> would be represented internally as $colon$minus$greater. Mixed Identifiers A mixed identifier consists of an alphanumeric identifier, which is followed by an underscore and an operator identifier. Following are legal mixed identifiers − unary_+, myvar_= Here, unary_+ used as a method name defines a unary + operator and myvar_= used as method name defines an assignment operator (operator overloading). Literal Identifiers A literal identifier is an arbitrary string enclosed in back ticks (` . . . `). Following are legal literal identifiers − `x` `<clinit>` `yield` Scala Keywords The following list shows the reserved words in Scala. These reserved words may not be used as constant or variable or any other identifier names. abstract case catch class def do else extends false final finally for forSome if implicit import lazy match new Null object override package private protected return sealed super this throw trait Try true type val Var while with yield
- 11. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 11 - : = => <- <: <% >: # @ Comments in Scala Scala supports single-line and multi-line comments very similar to Java. Multi-line comments may be nested, but are required to be properly nested. All characters available inside any comment are ignored by Scala compiler. object HelloWorld { /* This is my first java program. * This will print 'Hello World' as the output * This is an example of multi-line comments. */ def main(args: Array[String]) { // Prints Hello World // This is also an example of single line comment. println("Hello, world!") } } Blank Lines and Whitespace A line containing only whitespace, possibly with a comment, is known as a blank line, and Scala totally ignores it. Tokens may be separated by whitespace characters and/or comments. Newline Characters Scala is a line-oriented language where statements may be terminated by semicolons (;) or newlines. A semicolon at the end of a statement is usually optional. You can type one if you want but you don't have to if the statement appears by itself on a single line. On the other hand, a semicolon is required if you write multiple statements on a single line. Below syntax is the usage of multiple statements. val s = "hello"; println(s) 1.2 Variables and Data Types Variables are nothing but reserved memory locations to store values. This means that when you create a variable, you reserve some space in memory.
- 12. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 12 Based on the data type of a variable, the compiler allocates memory and decides what can be stored in the reserved memory. Therefore, by assigning different data types to variables, you can store integers, decimals, or characters in these variables. Variable Declaration Scala has a different syntax for declaring variables. They can be defined as value, i.e., constant or a variable. Here, myVar is declared using the keyword var. It is a variable that can change value and this is called mutable variable. Following is the syntax to define a variable using var keyword − Syntax var myVar : String = "Foo" Here, myVal is declared using the keyword val. This means that it is a variable that cannot be changed and this is called immutable variable. Following is the syntax to define a variable using val keyword − Syntax val myVal : String = "Foo" Variable Data Types The type of a variable is specified after the variable name and before equals sign. You can define any type of Scala variable by mentioning its data type as follows − Syntax val or val VariableName : DataType = [Initial Value] If you do not assign any initial value to a variable, then it is valid as follows − Syntax var myVar :Int; val myVal :String; Variable Type Inference When you assign an initial value to a variable, the Scala compiler can figure out the type of the variable based on the value assigned to it. This is called variable type inference. Therefore, you could write these variable declarations like this − Syntax
- 13. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 13 var myVar = 10; val myVal = "Hello, Scala!"; Here, by default, myVar will be Int type and myVal will become String type variable. Multiple assignments Scala supports multiple assignments. If a code block or method returns a Tuple (Tuple − Holds collection of Objects of different types), the Tuple can be assigned to a val variable. [Note − We will study Tuples in subsequent chapters.] Syntax val (myVar1: Int, myVar2: String) = Pair(40, "Foo") And the type inference gets it right − Syntax val (myVar1, myVar2) = Pair(40, "Foo") Example Program The following is an example program that explains the process of variable declaration in Scala. This program declares four variables — two variables are defined with type declaration and remaining two are without type declaration. Example object Demo { def main(args: Array[String]) { var myVar :Int = 10; val myVal :String = "Hello Scala with datatype declaration."; var myVar1 = 20; val myVal1 = "Hello Scala new without datatype declaration."; println(myVar); println(myVal); println(myVar1); println(myVal1); } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command
- 14. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 14 >scalac Demo.scala >scala Demo Output 10 Hello Scala with datatype declaration. 20 Hello Scala without datatype declaration. Variable Scope Variables in Scala can have three different scopes depending on the place where they are being used. They can exist as fields, as method parameters and as local variables. Below are the details about each type of scope. Fields Fields are variables that belong to an object. The fields are accessible from inside every method in the object. Fields can also be accessible outside the object depending on what access modifiers the field is declared with. Object fields can be both mutable and immutable types and can be defined using either var or val. Method Parameters Method parameters are variables, which are used to pass the value inside a method, when the method is called. Method parameters are only accessible from inside the method but the objects passed in may be accessible from the outside, if you have a reference to the object from outside the method. Method parameters are always immutable which are defined byval keyword. Local Variables Local variables are variables declared inside a method. Local variables are only accessible from inside the method, but the objects you create may escape the method if you return them from the method. Local variables can be both mutable and immutable types and can be defined using either var or val. Data types: Scala has all the same data types as Java, with the same memory footprint and precision. Following is the table giving details about all the data types available in Scala − Sr.No Data Type & Description
- 15. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 15 1 Byte 8 bit signed value. Range from -128 to 127 2 Short 16 bit signed value. Range -32768 to 32767 3 Int 32 bit signed value. Range -2147483648 to 2147483647 4 Long 64 bit signed value. -9223372036854775808 to 9223372036854775807 5 Float 32 bit IEEE 754 single-precision float 6 Double 64 bit IEEE 754 double-precision float 7 Char 16 bit unsigned Unicode character. Range from U+0000 to U+FFFF 8 String A sequence of Chars 9 Boolean Either the literal true or the literal false 10 Unit Corresponds to no value 11 Null
- 16. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 16 null or empty reference 12 Nothing The subtype of every other type; includes no values 13 Any The supertype of any type; any object is of type Any 14 AnyRef The supertype of any reference type All the data types listed above are objects. There are no primitive types like in Java. This means that you can call methods on an Int, Long, etc. Scala Basic Literals The rules Scala uses for literals are simple and intuitive. This section explains all basic Scala Literals. Integral Literals Integer literals are usually of type Int, or of type Long when followed by a L or l suffix. Here are some integer literals − 0 035 21 0xFFFFFFFF 0777L Floating Point Literal Floating point literals are of type Float when followed by a floating point type suffix F or f, and are of type Double otherwise. Here are some floating point literals − 0.0 1e30f 3.14159f 1.0e100 .1
- 17. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 17 Boolean Literals The Boolean literals true and false are members of type Boolean. Symbol Literals A symbol literal 'x is a shorthand for the expression scala.Symbol("x"). Symbol is a case class, which is defined as follows. package scala final case class Symbol private (name: String) { override def toString: String = "'" + name } Character Literals A character literal is a single character enclosed in quotes. The character is either a printable Unicode character or is described by an escape sequence. Here are some character literals − 'a' 'u0041' 'n' 't' String Literals A string literal is a sequence of characters in double quotes. The characters are either printable Unicode character or are described by escape sequences. Here are some string literals − "Hello,nWorld!" "This string contains a " character." Multi-Line Strings A multi-line string literal is a sequence of characters enclosed in triple quotes """ ... """. The sequence of characters is arbitrary, except that it may contain three or more consecutive quote characters only at the very end. Characters must not necessarily be printable; newlines or other control characters are also permitted. Here is a multi-line string literal − """the present string spans three lines.""" Null Values
- 18. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 18 The null value is of type scala.Null and is thus compatible with every reference type. It denotes a reference value which refers to a special "null" object. Escape Sequences The following escape sequences are recognized in character and string literals. Escape Sequences Unicode Description b u0008 backspace BS t u0009 horizontal tab HT n u000c formfeed FF f u000c formfeed FF r u000d carriage return CR " u0022 double quote " ' u0027 single quote . u005c backslash A character with Unicode between 0 and 255 may also be represented by an octal escape, i.e., a backslash '' followed by a sequence of up to three octal characters. Following is the example to show few escape sequence characters − Example object Test { def main(args: Array[String]) { println("HellotWorldnn" ); } }
- 19. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 19 When the above code is compiled and executed, it produces the following result − Output Hello World 1.4 Operators : An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Scala is rich in built-in operators and provides the following types of operators − Arithmetic Operators Relational Operators Logical Operators Bitwise Operators Assignment Operators This chapter will examine the arithmetic, relational, logical, bitwise, assignment and other operators one by one. Arithmetic Operators The following arithmetic operators are supported by Scala language. For example, let us assume variable A holds 10 and variable B holds 20, then – Operator Description Example + Adds two operands A + B will give 30 - Subtracts second operand from the first A - B will give -10 * Multiplies both operands A * B will give 200 / Divides numerator by de-numerator B / A will give 2 % Modulus operator finds the remainder after B % A will give 0
- 20. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 20 division of one number by another Relational Operators The following relational operators are supported by Scala language. For example let us assume variable A holds 10 and variable B holds 20, then − Operator Description Example == Checks if the values of two operands are equal or not, if yes then condition becomes true. (A == B) is not true. != Checks if the values of two operands are equal or not, if values are not equal then condition becomes true. (A != B) is true. > Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. (A > B) is not true. < Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. (A < B) is true. >= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. (A >= B) is not true. <= Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. (A <= B) is true. Logical Operators
- 21. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 21 The following logical operators are supported by Scala language. For example, assume variable A holds 1 and variable B holds 0, then − Show Examples Operator Description Example && It is called Logical AND operator. If both the operands are non zero then condition becomes true. (A && B) is false. || It is called Logical OR Operator. If any of the two operands is non zero then condition becomes true. (A || B) is true. ! It is called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. !(A && B) is true. Bitwise Operators Bitwise operator works on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows − p q p & q p | q p ^ q 0 0 0 0 0 0 1 0 1 1 1 1 1 1 0 1 0 0 1 1 Assume if A = 60; and B = 13; now in binary format they will be as follows −
- 22. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 22 A = 0011 1100 B = 0000 1101 ----------------------- A&B = 0000 1100 A|B = 0011 1101 A^B = 0011 0001 ~A = 1100 0011 The Bitwise operators supported by Scala language is listed in the following table. Assume variable A holds 60 and variable B holds 13, then − Operato r Description Example & Binary AND Operator copies a bit to the result if it exists in both operands. (A & B) will give 12, which is 0000 1100 | Binary OR Operator copies a bit if it exists in either operand. (A | B) will give 61, which is 0011 1101 ^ Binary XOR Operator copies the bit if it is set in one operand but not both. (A ^ B) will give 49, which is 0011 0001 ~ Binary Ones Complement Operator is unary and has the effect of 'flipping' bits. (~A ) will give -61, which is 1100 0011 in 2's complement form due to a signed binary number. << Binary Left Shift Operator. The bit positions of the left operands value is moved left by the number of bits specified by the right operand. A << 2 will give 240, which is 1111 0000 >> Binary Right Shift Operator. The Bit positions of the left operand value is moved right by the number of bits specified by the right operand. A >> 2 will give 15, which is 1111 >>> Shift right zero fill operator. The left operands value is moved right by the number of bits A >>>2 will give 15 which is 0000 1111
- 23. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 23 specified by the right operand and shifted values are filled up with zeros. Assignment Operators There are following assignment operators supported by Scala language − Show Examples Operator Description Example = Simple assignment operator, Assigns values from right side operands to left side operand C = A + B will assign value of A + B into C += Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand C += A is equivalent to C = C + A -= Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand C -= A is equivalent to C = C - A *= Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand C *= A is equivalent to C = C * A /= Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand C /= A is equivalent to C = C / A %= Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand C %= A is equivalent to C = C % A <<= Left shift AND assignment operator C <<= 2 is same as C = C << 2 >>= Right shift AND assignment operator C >>= 2 is same as C = C >> 2
- 24. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 24 &= Bitwise AND assignment operator C &= 2 is same as C = C & 2 ^= bitwise exclusive OR and assignment operator C ^= 2 is same as C = C ^ 2 |= bitwise inclusive OR and assignment operator C |= 2 is same as C = C | 2 Operators Precedence in Scala Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator − For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7. Take a look at the following table. Operators with the highest precedence appear at the top of the table and those with the lowest precedence appear at the bottom. Within an expression, higher precedence operators will be evaluated first. Category Operator Associativity Postfix () [] Left to right Unary ! ~ Right to left Multiplicative * / % Left to right Additive + - Left to right Shift >> >>> << Left to right Relational > >= < <= Left to right Equality == != Left to right
- 25. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 25 Bitwise AND & Left to right Bitwise XOR ^ Left to right Bitwise OR | Left to right Logical AND && Left to right Logical OR || Left to right Assignment = += -= *= /= %= >>= <<= &= ^= |= Right to left Comma , Left to right 1.5: Expressions, Values, and Types Basic Expressions The code below shows a basic expression in Scala : val x = 5 + 10 // EXPRESSION Expressions are evaluated by the compiler to a value, in this case 15. They also have a type, in this case Int. The type gets figured out by the compiler without us having to specify it. This is called Type Inference in Scala. The above expression is mathematical. We could also write another expression that tests for equality like so: println(x == 3) This expression evaluates to a boolean, checking whether or not the value of x is 3, which in this case is false.
- 26. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 26 Instructions vs Expressions Instructions tell the computer to go and do something, for example print to the console or change the value of a variable. These are used in imperative languages such as Java or Python Expressions something that has a value and/or a type. In Scala (and in functional programming in general) we will start to think in terms of Expressions. Everything in Scala is an Expression. Only definitions such as val or class or package are not expressions, everything else is. We can look at an if expression in Scala to see an example of this. val someCondition = true val conditionedValue = if(someCondition) 10 else 5 What this code is saying for the conditionedValue is “if someCondition is true then the value is 10, otherwise 5”. This is an expression, because it gives back a value. You could also just write this straight to the console (i.e. without storing it in a val or var) as below. Both of these lines are expressions in the parentheses that return a value: println(if(someCondition) 10 else 5) println(2 + 3) Values and types Create an object called Values and extend it from App, so that we can run it. Type in the following code: object Values extends App { val x: Int = 99 println(x) } Here we are declaring a VALUE called x, and we are telling the compiler it is of type Int. We then assign it the value 99. On the next line, we simply print out the value A key thing to note here, is that once a VAL has been declared, it can’t be reassigned.
- 27. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 27 For example, the following code would produce an error : object Values extends App { val x: Int = 42 println(x) x = 66 } So remember that Vals are immutable. The functional programming style of Scala encourages the use of these immutable vals. Type Inference It isn’t always necessary to include the type when declaring a val. You could instead type: object Values extends App { val x = 42 println(x) } And this would run fine. The type is detected by the compiler by looking at the value assigned to the variable. This is known as Type Inference. The Basic Types These are some of the really basic types in Scala, which you should be familiar with from other programming languages: val myString: String = "James" val myBoolean: Boolean = true val myChar: Char = 'd' val myInt: Int = 33 val myShort: Short = 326
- 28. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 28 val myLong: Long = 35263256234L // notice the L on the end - this tells the compiler its a Long val myFloat: Float = 3.0f // again notice the f on the end val myDouble: Double = 4.27 1.6 Classes and objects A class is a blueprint for objects. Once you define a class, you can create objects from the class blueprint with the keyword new. Through the object you can use all functionalities of the defined class. In scala, a class can contain: Data member Member method Constructor Block Nested class Super class information etc. You must initialize all instance variables in the class. There is no default scope. If you don't specify access scope, it is public. There must be an object in which main method is defined. It provides starting point for your program. Here, we have created an example of class. The following diagram demonstrates the class and object by taking an example of class student, which contains the member variables (name and roll no) and member methods (setName() and setRollNo()). Finally all are members of the class. Class is a blue print and objects are real here. In the following diagram, Student is a class and Harini, John, and Maria are the objects of Student class, those are having name and roll-number.
- 29. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 29 Basic Class class Student{ var id:Int = 0; // All fields must be initialized var name:String = null; } object MainObject{ def main(args:Array[String]){ var s = new Student() // Creating an object println(s.id+" "+s.name); } } Output: 0 null Scala Sample Example2 of Class In scala, you can create class like this also. Here, constructor is created in class definition. This is called primary constructor. class Student(id:Int, name:String){ // Primary constructor def show(){ println(id+" "+name) } } object MainObject{ def main(args:Array[String]){ var s = new Student(100,"Martin") // Passing values to constructor s.show() // Calling a function by using an object } } Output: 100 Martin Scala Example of class that maintains the records of students class Student(id:Int, name:String){ def getRecord(){ println(id+" "+name); } } object MainObject{ def main(args: Array[String]){ var student1 = new Student(101,"Raju"); var student2 = new Student(102,"Martin"); student1.getRecord();
- 30. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 30 student2.getRecord(); } } Output: 101 Raju 102 Martin Scala Anonymous object In scala, you can create anonymous object. An object which has no reference name is called anonymous object. It is good to create anonymous object when you don't want to reuse it further. Scala Anonymous object Example class Arithmetic{ def add(a:Int, b:Int){ var add = a+b; println("sum = "+add); } } object MainObject{ def main(args:Array[String]){ new Arithmetic().add(10,10); } } Output: Sum = 20 Object Object is a real world entity. It contains state and behavior. Laptop, car, cell phone are the real world objects. Object typically has two characteristics: 1) State: data values of an object are known as its state. 2) Behavior: functionality that an object performs is known as its behavior. Object in scala is an instance of class. It is also known as runtime entity. 1.7 Control statements and Looping Statements Scala provides if statement to test the conditional expressions. It tests boolean conditional expression which can be either true or false. Scala use various types of if else statements. If statement If-else statement
- 31. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 31 Nested if-else statement If-else-if ladder statement if Statement ‘if’ statement consists of a Boolean expression followed by one or more statements. Syntax The syntax of an ‘if’ statement is as follows. if(Boolean_expression) { // Statements will execute if the Boolean expression is true } If the Boolean expression evaluates to true then the block of code inside the ‘if’ expression will be executed. If not, the first set of code after the end of the ‘if’ expression (after the closing curly brace) will be executed. Try the following example program to understand conditional expressions (if expression) in Scala Programming Language. Example object Demo { def main(args: Array[String]) { var x = 10; if( x < 20 ){ println("This is if statement"); } } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output This is if statement
- 32. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 32 If-else Statement An ‘if’ statement can be followed by an optional else statement, which executes when the Boolean expression is false. Syntax The syntax of a if...else is − if(Boolean_expression){ //Executes when the Boolean expression is true } else{ //Executes when the Boolean expression is false } Try the following example program to understand conditional statements (if- else statement) in Scala Programming Language. Example object Demo { def main(args: Array[String]) { var x = 30; if( x < 20 ){ println("This is if statement"); } else { println("This is else statement"); } } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output This is else statement Nested if-else Statement
- 33. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 33 It is always legal to nest if-else statements, which means you can use one if or else-ifstatement inside another if or else-if statement. Syntax The syntax for a nested if-else is as follows − if(Boolean_expression 1){ //Executes when the Boolean expression 1 is true if(Boolean_expression 2){ //Executes when the Boolean expression 2 is true } } Try the following example program to understand conditional statements (nested- if statement) in Scala Programming Language. Example object Demo { def main(args: Array[String]) { var x = 30; var y = 10; if( x == 30 ){ if( y == 10 ){ println("X = 30 and Y = 10"); } } } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output X = 30 and Y = 10
- 34. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 34 Scala If-Else-If Ladder Statement The scala if-else-if ladder executes one condition among the multiple conditional statements. Syntax if (condition1){ //Code to be executed if condition1 is true } else if (condition2){ //Code to be executed if condition2 is true } else if (condition3){ //Code to be executed if condition3 is true } ... else { //Code to be executed if all the conditions are false } If-Else-If Ladder Example var number:Int = 85 if(number>=0 && number<50){ println ("fail") } else if(number>=50 && number<60){ println("D Grade") } else if(number>=60 && number<70){ println("C Grade") } else if(number>=70 && number<80){ println("B Grade") } else if(number>=80 && number<90){ println("A Grade") } else if(number>=90 && number<=100){ println("A+ Grade") } else println ("Invalid") Output: A Grade
- 35. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 35 Looping Statements There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. Programming languages provide various control structures that allow for more complicated execution paths. A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages Scala programming language provides the following types of loops to handle looping requirements. Click the following links in the table to check their detail. Sr.No Loop Type & Description 1 while loop Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body. 2 do-while loop Like a while statement, except that it tests the condition at the end of the loop body. 3 for loop Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable. Loop Control Statements Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed. As such Scala does not support break or continue statement like Java does but starting from Scala version 2.8, there is a way to break the loops. Click the following links to check the detail. Sr.No Control Statement & Description 1 break statement Terminates the loop statement and transfers execution to the statement
- 36. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 36 immediately following the loop. The infinite Loop A loop becomes an infinite loop if a condition never becomes false. If you are using Scala, the while loop is the best way to implement infinite loop. Example object Demo { def main(args: Array[String]) { var a = 10; // An infinite loop. while( true ){ println( "Value of a: " + a ); } } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output If you will execute above code, it will go in infinite loop which you can terminate by pressing Ctrl + C keys. Value of a: 10 Value of a: 10 Value of a: 10 Value of a: 10 while loop Example object MainObject { def main(args: Array[String]) { var a = 10; // Initialization while( a<=20 ){ // Condition println(a); a = a+2 // Incrementation }
- 37. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 37 } } do-while loop example object MainObject { def main(args: Array[String]) { var a = 10; // Initialization do { println( a ); a = a + 2; // Increment } while( a <= 20 ) // Condition } } for loop In scala, for loop is known as for-comprehensions. It can be used to iterate, filter and return an iterated collection. The for-comprehension looks a bit like a for-loop in imperative languages, except that it constructs a list of the results of all iterations. Syntax for( i <- range){ // statements to be executed } In the above syntax, range is a value which has start and end point. You can pass range by using to or until keyword. Scala for-loop example by using to keyword object MainObject { def main(args: Array[String]) { for( a <- 1 to 10 ){ println(a); } } } The major difference between until and to is, to includes start and end value given in the range, while until excludes last value of the range. So, the below example will print only 1 to 9. Scala for-loop Example by using until keyword object MainObject { def main(args: Array[String]) { for( a <- 1 until 10 ){ println(a); }
- 38. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 38 } } for-loop filtering Example You can use for to filter your data. In the below example, we are filtering our data by passing a conditional expression. This program prints only even values in the given range. object MainObject { def main(args: Array[String]) { for( a <- 1 to 10 if a%2==0 ){ println(a); } } } for-loop Example by using yield keyword In the above example, we have used yield keyword which returns a result after completing of loop iterations. The for use buffer internally to store iterated result and after finishing all iterations it yields the final result from that buffer. It does not work like imperative loop. object MainObject { def main(args: Array[String]) { var result = for( a <- 1 to 10) yield a for(i<-result){ println(i) } } } for-loop Example using by keyword In the above example, we have used by keyword. The by keyword is used to skip the iteration. When you code like: by 2 it means, this loop will skip all even iterations of loop. object MainObject { def main(args: Array[String]) { for(i<-1 to 10 by 2){ println(i) } } } 1.8 Strings
- 39. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 39 String is a combination of characters or we can say it is a sequence of characters. It is index based data structure and use linear approach to store data into memory. String is immutable in scala like java. You can manipulate string and can apply method to get desire result but you can't change original string object. Creating a String The following code can be used to create a String − var greeting = "Hello world!"; or var greeting:String = "Hello world!"; Whenever compiler encounters a string literal in the code, it creates a String object with its value, in this case, “Hello world!”. String keyword can also be given in alternate declaration as shown above. Try the following example program. Example object Demo { val greeting: String = "Hello, world!" def main(args: Array[String]) { println( greeting ) } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output Hello, world! As mentioned earlier, String class is immutable. String object once created cannot be changed. If there is a necessity to make a lot of modifications to Strings of characters then use String Builder Class available in Scala!.
- 40. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 40 String Length Methods used to obtain information about an object are known as accessor methods. One accessor method that can be used with strings is the length() method, which returns the number of characters contained in the string object. Use the following code segment to find the length of a string − Example object Demo { def main(args: Array[String]) { var palindrome = "Dot saw I was Tod"; var len = palindrome.length(); println( "String Length is : " + len ); } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output String Length is : 17 Concatenating Strings The String class includes a method for concatenating two strings − string1.concat(string2); This returns a new string that is string1 with string2 added to it at the end. You can also use the concat() method with string literals, as in − "My name is ".concat("Zara"); Strings are more commonly concatenated with the + operator, as in − "Hello," + " world" + "!" Which results in − "Hello, world!"
- 41. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 41 The following lines of code to find string length. Example object Demo { def main(args: Array[String]) { var str1 = "Dot saw I was "; var str2 = "Tod"; println("Dot " + str1 + str2); } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output Dot Dot saw I was Tod Creating Format Strings You have printf() and format() methods to print output with formatted numbers. The String class has an equivalent class method, format(), that returns a String object rather than a PrintStream object. Try the following example program, which makes use of printf() method − Example object Demo { def main(args: Array[String]) { var floatVar = 12.456 var intVar = 2000 var stringVar = "Hello, Scala!" var fs = printf("The value of the float variable is " + "%f, while the value of the integer " + "variable is %d, and the string" + "is %s", floatVar, intVar, stringVar); println(fs)
- 42. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 42 } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. command >scalac Demo.scala >scala Demo Output The value of the float variable is 12.456000, while the value of the integer variable is 2000, and the string is Hello, Scala!() String Interpolation String Interpolation is the new way to create Strings in Scala programming language. This feature supports the versions of Scala-2.10 and later. String Interpolation: The mechanism to embed variable references directly in process string literal. There are three types (interpolators) of implementations in String Interpolation. The ‘s’ String Interpolator The literal ‘s’ allows the usage of variable directly in processing a string, when you prepend ‘s’ to it. Any String variable with in a scope that can be used with in a String. The following are the different usages of ‘s’ String interpolator. The following example code snippet for the implementation of ‘s’ interpolator in appending String variable ($name) to a normal String (Hello) in println statement. val name = “James” println(s “Hello, $name”) //output: Hello, James String interpolater can also process arbitrary expressions. The following code snippet for Processing a String (1 + 1) with arbitrary expression (${1 + 1}) using ‘s’ String interpolator. Any arbitrary expression can be embedded in ‘${}’. println(s “1 + 1 = ${1 + 1}”) //output: 1 + 1 = 2 Try the following example program of implementing ‘s’ interpolator. Example
- 43. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 43 object Demo { def main(args: Array[String]) { val name = "James" println(s"Hello, $name") println(s"1 + 1 = ${1 + 1}") } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output Hello, James 1 + 1 = 2 The ‘ f ’ Interpolator The literal ‘f’ interpolator allows to create a formatted String, similar to printf in C language. While using ‘f’ interpolator, all variable references should be followed by the printf style format specifiers such as %d, %i, %f, etc. Let us take an example of append floating point value (height = 1.9d) and String variable (name = “James”) with normal string. The following code snippet of implementing ‘f’ Interpolator. Here $name%s to print (String variable) James and $height%2.2f to print (floating point value) 1.90. val height = 1.9d val name = "James" println(f"$name%s is $height%2.2f meters tall") //James is 1.90 meters tall It is type safe (i.e.) the variable reference and following format specifier should match otherwise it is showing error. The ‘ f ’ interpolator makes use of the String format utilities (format specifiers) available in Java. By default means, there is no % character after variable reference. It will assume as %s (String). ‘raw’ Interpolator The ‘raw’ interpolator is similar to ‘s’ interpolator except that it performs no escaping of literals within a string. The following code snippets in a table will differ the usage of ‘s’ and ‘raw’
- 44. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 44 interpolators. In outputs of ‘s’ usage ‘n’ effects as new line and in output of ‘raw’ usage the ‘n’ will not effect. It will print the complete string with escape letters. ‘s’ interpolator usage ‘raw’ interpolator usage Program − object Demo { def main(args: Array[String]) { println(s"Result = n a n b") } } Program − object Demo { def main(args: Array[String]) { println(raw"Result = n a n b") } } Output − Result = a b String Methods S.No Methods with Description 1 char charAt(int index) Returns the character at the specified index. 2 int compareTo(Object o) Compares this String to another Object. 3 int compareTo(String anotherString) Compares two strings lexicographically. 4 int compareToIgnoreCase(String str) Compares two strings lexicographically, ignoring case differences. 5 String concat(String str) Concatenates the specified string to the end of this string. 6 boolean contentEquals(StringBuffer sb) Returns true if and only if this String represents the same sequence of characters as the specified StringBuffer. 7 static String copyValueOf(char[] data) Returns a String that represents the character sequence in the array specified. 8 static String copyValueOf(char[] data, int offset, int count) Returns a String that represents the character sequence in the array specified.
- 45. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 45 9 boolean endsWith(String suffix) Tests if this string ends with the specified suffix. 10 boolean equals(Object anObject) Compares this string to the specified object. 11 boolean equalsIgnoreCase(String anotherString) Compares this String to another String, ignoring case considerations. 12 byte getBytes() Encodes this String into a sequence of bytes using the platform's default charset, storing the result into a new byte array. 13 byte[] getBytes(String charsetName) Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array. 14 void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) Copies characters from this string into the destination character array. 15 int hashCode() Returns a hash code for this string. 16 int indexOf(int ch) Returns the index within this string of the first occurrence of the specified character. 17 int indexOf(int ch, int fromIndex) Returns the index within this string of the first occurrence of the specified character, starting the search at the specified index. 18 int indexOf(String str) Returns the index within this string of the first occurrence of the specified substring. 19 int indexOf(String str, int fromIndex) Returns the index within this string of the first occurrence of the specified substring, starting at the specified index. 20 String intern() Returns a canonical representation for the string object. 21 int lastIndexOf(int ch) Returns the index within this string of the last occurrence of the specified character. 22 int lastIndexOf(int ch, int fromIndex) Returns the index within this string of the last occurrence of the specified character, searching backward starting at the specified index. 23 int lastIndexOf(String str) Returns the index within this string of the rightmost occurrence of the specified substring.
- 46. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 46 24 int lastIndexOf(String str, int fromIndex) Returns the index within this string of the last occurrence of the specified substring, searching backward starting at the specified index. 25 int length() Returns the length of this string. 26 boolean matches(String regex) Tells whether or not this string matches the given regular expression. 27 boolean regionMatches(boolean ignoreCase, int toffset, String other, int offset, int len) Tests if two string regions are equal. 28 boolean regionMatches(int toffset, String other, int offset, int len) Tests if two string regions are equal. 29 String replace(char oldChar, char newChar) Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar. 30 String replaceAll(String regex, String replacement Replaces each substring of this string that matches the given regular expression with the given replacement. 31 String replaceFirst(String regex, String replacement) Replaces the first substring of this string that matches the given regular expression with the given replacement. 32 String[] split(String regex) Splits this string around matches of the given regular expression. 33 String[] split(String regex, int limit) Splits this string around matches of the given regular expression. 34 boolean startsWith(String prefix) Tests if this string starts with the specified prefix. 35 boolean startsWith(String prefix, int toffset) Tests if this string starts with the specified prefix beginning a specified index. 36 CharSequence subSequence(int beginIndex, int endIndex) Returns a new character sequence that is a subsequence of this sequence. 37 String substring(int beginIndex) Returns a new string that is a substring of this string. 38 String substring(int beginIndex, int endIndex) Returns a new string that is a substring of this string. 39 char[] toCharArray()
- 47. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 47 Converts this string to a new character array. 40 String toLowerCase() Converts all of the characters in this String to lower case using the rules of the default locale. 41 String toLowerCase(Locale locale) Converts all of the characters in this String to lower case using the rules of the given Locale. 42 String toString() This object (which is already a string!) is itself returned. 43 String toUpperCase() Converts all of the characters in this String to upper case using the rules of the default locale. 44 String toUpperCase(Locale locale) Converts all of the characters in this String to upper case using the rules of the given Locale. 45 String trim() Returns a copy of the string, with leading and trailing whitespace omitted. 46 static String valueOf(primitive data type x) Returns the string representation of the passed data type argument. Example class StringExample{ var s1 = "Scala string example" var s2 = "Hello Scala" var s3 = "Hello Scala" def show(){ println(s1.equals(s2)) println(s2.equals(s3)) } } object MainObject{ def main(args:Array[String]){ var s = new StringExample() s.show() } } 1.9 Arrays Array is a collection of mutable values. It is an index based data structure which starts from 0 index to n-1 where n is length of array.
- 48. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 48 Scala arrays can be generic. It means, you can have an Array[T], where T is a type parameter or abstract type. Scala arrays are compatible with Scala sequences - you can pass an Array[T] where a Seq[T] is required. It also supports all the sequence operations. Following image represents the structure of array where first index is 0, last index is 9 and array length is 10. Types of array Single dimensional array Multidimensional array Single Dimensional Array Single dimensional array is used to store elements in linear order. Array elements are stored in contiguous memory space. So, if you have any index of an array, you can easily traverse all the elements of the array. Syntax for Single Dimensional Array var arrayName : Array[arrayType] = new Array[arrayType](arraySize); or var arrayName = new Array[arrayType](arraySize) or var arrayName : Array[arrayType] = new Array(arraySize); or var arrayName = Array(element1, element2 ... elementN) Array Example: Single Dimensional class ArrayExample{ var arr = Array(1,2,3,4,5) // Creating single dimensional array def show(){ for(a<-arr) // Traversing array elements println(a) println("Third Element = "+ arr(2)) // Accessing elements by using index } }
- 49. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 49 object MainObject{ def main(args:Array[String]){ var a = new ArrayExample() a.show() } } Output: 1 2 3 4 5 Third Element = 3 Example 2: Single Dimensional In this example, we have created an array by using new keyword which is used to initialize memory for array. The entire array elements are set to default value, you can assign that later in your code. class ArrayExample{ var arr = new Array[Int](5) // Creating single dimensional array def show(){ for(a<-arr){ // Traversing array elements println(a) } println("Third Element before assignment = "+ arr(2)) // Accessing elements by using index arr(2) = 10 // Assigning new element at 2 index println("Third Element after assignment = "+ arr(2)) } } object MainObject{ def main(args:Array[String]){ var a = new ArrayExample() a.show() } } Output: 0
- 50. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 50 0 0 0 0 Third Element before assignment = 0 Third Element after assignment = 10 Scala Passing Array into Function You can pass array as an argument to function during function call. Following example illustrate the process how we can pass an array to the function. class ArrayExample{ def show(arr:Array[Int]){ for(a<-arr) // Traversing array elements println(a) println("Third Element = "+ arr(2)) // Accessing elements by using index } } object MainObject{ def main(args:Array[String]){ var arr = Array(1,2,3,4,5,6) // creating single dimensional array var a = new ArrayExample() a.show(arr) // passing array as an argument in the function } } Output: 1 2 3 4 5 6 Third Element = 3 Array Example: Iterating By using Foreach Loop You can also iterate array elements by using foreach loop. Let's see an example. class ArrayExample{ var arr = Array(1,2,3,4,5) // Creating single dimensional array arr.foreach((element:Int)=>println(element)) // Iterating by using foreach loop }
- 51. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 51 object MainObject{ def main(args:Array[String]){ new ArrayExample() } } Output: 1 2 3 4 5 Multidimensional Array Multidimensional array is an array which store data in matrix form. You can create from two dimensional to three, four and many more dimensional array according to your need. Below we have mentioned array syntax. Scala provides an ofDim method to create multidimensional array. Multidimensional Array Syntax var arrayName = Array.ofDim[ArrayType](NoOfRows,NoOfColumns) or var arrayName = Array(Array(element...), Array(element...), ...) Scala Multidimensional Array Example by using ofDim In This example, we have created array by using ofDim method. class ArrayExample{ var arr = Array.ofDim[Int](2,2) // Creating multidimensional array arr(1)(0) = 15 // Assigning value def show(){ for(i<- 0 to 1){ // Traversing elements by using loop for(j<- 0 to 1){ print(" "+arr(i)(j)) } println() } println("Third Element = "+ arr(1)(1)) // Accessing elements by using index } } object MainObject{ def main(args:Array[String]){ var a = new ArrayExample() a.show()
- 52. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 52 } } Output: 0 0 15 0 Third Element = 0 Scala Multidimensional Array by using Array of Array Apart from ofDim you can also create multidimensional array by using array of array. In this example, we have created multidimensional array by using array of array. class ArrayExample{ var arr = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) // Creating multidimensional array def show(){ for(i<- 0 to 1){ // Traversing elements using loop for(j<- 0 to 4){ print(" "+arr(i)(j)) } println() } } } object MainObject{ def main(args:Array[String]){ var a = new ArrayExample() a.show() } } Output: 1 2 3 4 5 6 7 8 9 10 Scala Addition of Two Matrix Example You can manipulate array elements in scala. Here, we are adding two array elements and storing result into third array. class ArrayExample{ var arr1 = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) // Creating multidimensional array var arr2 = Array(Array(1,2,3,4,5), Array(6,7,8,9,10)) var arr3 = Array.ofDim[Int](2,5)
- 53. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 53 def show(){ for(i<- 0 to 1){ // Traversing elements using loop for(j<- 0 to 4){ arr3(i)(j) = arr1(i)(j)+arr2(i)(j) print(" "+arr3(i)(j)) } println() } } } object MainObject{ def main(args:Array[String]){ var a = new ArrayExample() a.show() } } Output: 2 4 6 8 10 12 14 16 18 20 1.10 Functions A function is a group of statements that perform a task. You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically, the division usually is so that each function performs a specific task. Scala has both functions and methods and we use the terms method and function interchangeably with a minor difference. A Scala method is a part of a class which has a name, a signature, optionally some annotations, and some bytecode where as a function in Scala is a complete object which can be assigned to a variable. In other words, a function, which is defined as a member of some object, is called a method. A function definition can appear anywhere in a source file and Scala permits nested function definitions, that is, function definitions inside other function definitions. Most important point to note is that Scala function's name can have characters like +, ++, ~, &,-, --, , /, :, etc. Function Declarations A Scala function declaration has the following form − def functionName ([list of parameters]) : [return type] Methods are implicitly declared abstract if you don’t use the equals sign and the method body.
- 54. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 54 Function Definitions A Scala function definition has the following form − Syntax def functionName ([list of parameters]) : [return type] = { function body return [expr] } Here, return type could be any valid Scala data type and list of parameters will be a list of variables separated by comma and list of parameters and return type are optional. Very similar to Java, a return statement can be used along with an expression in case function returns a value. Following is the function which will add two integers and return their sum − Syntax object add { def addInt( a:Int, b:Int ) : Int = { var sum:Int = 0 sum = a + b return sum } } A function, that does not return anything can return a Unit that is equivalent to void in Java and indicates that function does not return anything. The functions which do not return anything in Scala, they are called procedures. Syntax Here is the syntax − object Hello{ def printMe( ) : Unit = { println("Hello, Scala!") } } Calling Functions Scala provides a number of syntactic variations for invoking methods. Following is the standard way to call a method − functionName( list of parameters )
- 55. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 55 Example object Demo { def main(args: Array[String]) { println( "Returned Value : " + addInt(5,7) ); } def addInt( a:Int, b:Int ) : Int = { var sum:Int = 0 sum = a + b return sum } } Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output Returned Value : 12 1.10.1 Higher-Order Functions Scala allows the definition of higher-order functions. These are functions that take other functions as parameters, or whose result is a function. Try the following example program, apply() function takes another function f and a value v and applies function f to v. Example object Demo { def main(args: Array[String]) { println( apply( layout, 10) ) } def apply(f: Int => String, v: Int) = f(v) def layout[A](x: A) = "[" + x.toString() + "]" }
- 56. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 56 Save the above program in Demo.scala. The following commands are used to compile and execute this program. Command >scalac Demo.scala >scala Demo Output [10] 1.10.2 Function Composition In scala, functions can be composed from other functions. It is a process of composing in which a function represents the application of two composed functions. Let's see an example. object MainObject { def main(args: Array[String]) = { var result = multiplyBy2(add2(10)) // Function composition println(result) } def add2(a:Int):Int = { a+2 } def multiplyBy2(a:Int):Int = { a*2 } } Output: 24 1.10.3 Scala Anonymous (lambda) Function Anonymous function is a function that has no name but works as a function. It is good to create an anonymous function when you don't want to reuse it latter. You can create anonymous function either by using => (rocket) or _ (underscore) wild card in scala. Let's see an example. Scala Anonymous function Example
- 57. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 57 object MainObject { def main(args: Array[String]) = { var result1 = (a:Int, b:Int) => a+b // Anonymous function by using => (rocket) var result2 = (_:Int)+(_:Int) // Anonymous function by using _ (underscore) wild card println(result1(10,10)) println(result2(10,10)) } } Output: 20 20 1.10.4 Scala Multiline Expression Expressions those are written in multiple lines are called multiline expression. In scala, be carefull while using multiline expressions. The following program explains about if we break an expression into multiline, the scala compiler throw a warning message. Scala Multiline Expression Example def add1(a:Int, b:Int) = { a +b } The above program does not evaluate complete expression and just return b here. So, be careful while using multiline expressions. Output: MainObject.scala:3: warning: a pure expression does nothing in statement position; you may be omitting necessary parentheses a ^ one warning found 10 You can apply following ways to avoid above problem. Scala Example Multiline Expression
- 58. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 58 object MainObject { def add2(a:Int, b:Int) = { a+ b } def add3(a:Int, b:Int) = { (a +b) } def main(args: Array[String]) = { var result2 = add2(10,10) var result3 = add3(10,10) println(result2+"n"+result3) } } Output: 20 20 1.10.5 Function Currying In scala, method may have multiple parameter lists. When a method is called with a fewer number of parameter lists, then this will yield a function taking the missing parameter lists as its arguments. In other words it is a technique of transforming a function that takes multiple arguments into a function that takes a single argument. Scala Function Currying Example object MainObject { def add(a:Int)(b:Int) = { a+b } def main(args: Array[String]) = { var result = add(10)(10) println("10 + 10 = "+result) var addIt = add(10)_ var result2 = addIt(3) println("10 + 3 = "+result2) } } Output: 20
- 59. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 59 1.10.6 Higher-Order Functions on Lists 1.10.7 Closures A closure is a function, whose return value depends on the value of one or more variables declared outside this function. The following piece of code with anonymous function. val multiplier = (i:Int) => i * 10 Here the only variable used in the function body, i * 10 , is i, which is defined as a parameter to the function. Try the following code − val multiplier = (i:Int) => i * factor There are two free variables in multiplier: i and factor. One of them, i, is a formal parameter to the function. Hence, it is bound to a new value each time multiplier is called. However, factor is not a formal parameter, then what is this? Let us add one more line of code. var factor = 3 val multiplier = (i:Int) => i * factor
- 60. Easwari Engineering College 191AIC302T-Object Oriented Programming with SCALA Unit-I Department of AI & DSPage 60 Now factor has a reference to a variable outside the function but in the enclosing scope. The function references factor and reads its current value each time. If a function has no external references, then it is trivially closed over itself. No external context is required. Example object Demo { def main(args: Array[String]) { println( "multiplier(1) value = " + multiplier(1) ) println( "multiplier(2) value = " + multiplier(2) ) } var factor = 3 val multiplier = (i:Int) => i * factor }