Unit 2 notes.pdf

191AIC302T-Object Oriented Programming with SCALA
Unit-II
Department of AI & DSPage 1
Scala OOPS Concepts - Objects and Class
Object and Class - Singleton object - Companion Objects - Case classes and objects –
Constructors – Method overloading and overriding – Field overriding - Extending a class –
implicit classes – inner classes – Traits - Pattern Matching – Extractors -Collection Classes
2.1 Object and Class
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.
Class
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.

Unit-II
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{
var s = new Student(100,"Martin") // Passing values to constructor
s.show() // Calling a function by using an object
}
}
Output:
100 Martin

Unit-II
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();
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{
new Arithmetic().add(10,10);
}
}
Output:
Sum = 20
2.2 Singleton object and Companion Objects
Singleton Object
 Singleton object is an object which is declared by using object keyword instead by class.
No object is required to call methods declared inside singleton object.

Unit-II
 In scala, there is no static concept. So scala creates a singleton object to provide entry
point for your program execution.
 If you don't create singleton object, your code will compile successfully but will not
produce any output. Methods declared inside Singleton Object are accessible globally. A
singleton object can extend classes and traits.
Scala Singleton Object Example
object Singleton{
SingletonObject.hello() // No need to create object.
}
}
object SingletonObject{
def hello(){
println("Hello, This is Singleton Object")
}
}
Scala Companion Object
 In scala, when you have a class with same name as singleton object, it is called
companion class and the singleton object is called companion object.
 The companion class and its companion object both must be defined in the same source
file.
Scala Companion Object Example
class ComapanionClass{
def hello(){
println("Hello, this is Companion Class.")
}
}

Unit-II
object CompanoinObject{
new ComapanionClass().hello()
println("And this is Companion Object.")
}
}
2.3 Case classes and objects
A Scala Case Class is like a regular class, except it is good for modeling immutable data. It also
serves useful in pattern matching, such a class has a default apply() method which handles object
construction. A scala case class also has all vals, which means they are immutable.
Creating a Case Class
The creation of case class is simple, the keyword case class is used to define it followed by its
name and a set of parameters that can be empty.
Syntax:
case class cc_Name (paramter(s))
Code snippet to create a case class in Scala
case class student(name: String, class: Int, marks: Int, result: String)
Case Objects
The case objects are nothing but the instances of case class in Scala.
Creating case objects
obj_name = cc_name(parameter_values)
Could you see and understood, there is no new keyword used in the definition of case object
which is because it uses the apply() method.
Example
case class student(name: String, standard: Int, marks: Int, result: String )
object myObject {
def main(args: Array[String]) {

Unit-II
// Creating a case Object
val student1 = student("Prem", 10, 89, "A+")
println("Case Object: " + student1)
}
}
Operations on the case class
Comparing Case Objects
In Scala, case objects can be compared using == expression which returns true or false based on
the comparison.
Syntax:
case_Obj1 == case_Obj2
Example
object myObject {
println("Case Object student1 : " + student1)
val student2 = student("Ramesh", 11, 56, "B")
val comp1 = student1 == student2
println("Comparison of student1 and student2 = " + comp1)
val comp2 = student1 == student3

Unit-II
println("Comparison of student1 and student3 = " + comp2)
}
}
Coping Case Class in Scala
 We can copy the contents of one case object to another fully and partially too.
 Copying case object using copy() method [shallow copy]:
 The copy() method on the case object is used to copy the contents of one object to another. This is
a shallow copy.
Syntax:
caseObj1 = caseObj2.copy()
Example
object myObject {
val copyObj = student1.copy()
println("Copied Object: " + copyObj)
}
}
2.4 Constructors
A constructor is a function that is called at the time of initialization of objects. A constructor is
just like a method of a class that contains instructions to be executed. The constructor has the
same name as the class and is called when the object of the class is initialized.
Default Primary Constructor
 In scala, if you don't specify primary constructor, compiler creates a constructor which is
known as primary constructor.
 All the statements of class body treated as part of constructor. It is also known as default
constructor.
Example:
class Student{
println("Hello from default constructor");
}

Unit-II
Scala programming language defines two types of constructors,
 Primary constructor
 Auxiliary constructor
1) Primary constructor
Also known as default constructor, a primary constructor is created when no other constructor is
defined. It has the same name as the class. It is defined by default in Scala.
Syntax:
class class_name(parameter list){
// statements to be executed...
}
Example:
class student(Sname: String, Ssubject: String, percentage: Int)
{
def result()
{
println("Student name: " + Sname);
println("Subject taken: " + Ssubject);
println("Percentage obtained:" + percentage);
}
}
object MyObject
{
def main(args: Array[String])
{
var obj = new student("Ramesh", "Maths", 78);
obj.result();
}
}
2) Auxiliary constructor
In a Scala class, programmers are allowed to create multiple constructors for a single class. But
there can be only one primary constructor of a class. Constructor that is explicitly defined by the
programmer other than the primary is known as an auxiliary constructor.
Syntax:
def this(parameter list){
//code to be executed

Unit-II
}
There can be multiple auxiliary constructors which can be differentiated by their parameter list. In
the definition of any auxiliary constructor, the first statement should be a call to the primary
constructor or another auxiliary constructor which is defined before the calling constructor using
"this" keyword.
Example:
class Student( Sname: String, sub: String)
{
var percentage: Float = 0.0f;
def display()
{
println("Student name: " + Sname);
println("Stream : " + sub);
println("percentage: " + percentage);
}
def this(Sname: String, sub: String, no:Int)
{
this(Sname, sub)
this.percentage = no/5
}
}
object Main
{
{
var obj = new Student("kirti", "biology", 345);
obj.display();
}
}
Constructor Overloading
 In scala, you can overload constructor. Let's see an example.
class Student(id:Int){
def this(id:Int, name:String)={
this(id)
println(id+" "+name)
}
println(id)

Unit-II
}
object MainObject{
new Student(101)
new Student(100,"India")
}
}
2.5 Method overloading and overriding
 Method overloading is a method that is redefined in different ways under the same name.
 Method overloading is one of the methods used to implement polymorphism in Scala.
Implementation of method overloading in Scala
To create an overloaded method in Scala, define multiple methods with the same name and
different parameter list and return type. This means defining multiple functions one with one
parameter of type ‘A’ other with two parameters, etc.
Syntax:
//Method 1 :
def fun (a : data_type ) {
// code to be executed
}
//Method 2 :
def fun(a : data_type , b : data_type ){
// code to be executed
}
Both these methods contribute to method overloading in Scala. Now, to create an overloaded
method can invert either of the following things in the function that lead to overloading the
method:
Methods with different parameter lists
Methods with different data types and order
Program to show implementation of method overloading in Scala | print area of different figures
using method overloading
object MyClass {

Unit-II
def peri(x:Int, y:Int){
println("The perimeter of rectangle is "+ (x+y))
}
def peri(a:Int , b:Int ,c:Int){
println("The perimeter of rectangle is "+ (a+b+c))
}
def peri(r:Int){
println("The perimeter of rectangle is "+ (2*(3.14)*r))
}
println("Program to print perimeter of different figures using method overloading: ")
println("Perimeter of rectangle: ")
peri(12 , 345)
println("Perimeter of triangle: ")
peri(3, 5, 8)
println("Perimeter of circle:")
peri(4)
}
}
Program to show implementation of method overloading in Scala | print data-type of the
parameter using method overloading
object MyClass {
def datatype(x:Int){
println("The parameter is of Integer datatype")
}
def datatype(x:Float){
println("The parameter is of Float data type")
}
def datatype(x:Char){
println("The parameter is of Character data type")
}
def datatype(x: Boolean){
println("The parameter is of Boolean data type")
}
println("Program to print data type using method overloading: ")
datatype(4)
datatype(4.0f)

Unit-II
datatype('f')
datatype(true)
}
}
Method Overriding
 When a subclass has the same name method as defined in the parent class, it is known as
method overriding. When subclass wants to provide a specific implementation for the
method defined in the parent class, it overrides method from parent class.
 In scala, you must use either override keyword or override annotation to override methods
from parent class.
Scala Method Overriding Example
class Vehicle{
def run(){
println("vehicle is running")
}
}
class Bike extends Vehicle{
override def run(){
println("Bike is running")
}
}
object MainObject{
var b = new Bike()
b.run()
}
}
Output:
Bike is running
2.6 Field overriding
Overriding is the concept in which the child class is allowed to redefine the members of the parent
class. Both methods and variables/ fields can be overridden in object-oriented programming. In
Scala as well both methods and Fields can be overridden but overriding of fields has some
restrictions on implementation.
Overriding fields in Scala

Unit-II
 For overriding fields in Scala, some rules must be kept in mind to avoid errors that arise
while implementing this concept,
 The use of override keyword is necessary to implement the concept field overriding. If
you missed the keyword an error will be prompted and execution of the code will be
stopped.
 Only fields that are defined using the val keyboard for defining fields in both parent class
and child class can be overridden.
 Fields that are defined using the var keyword cannot be overridden as they are editable (
that is both read and write operations are allowed on the variable) anywhere in the class.
Here are some programs that show the implementation of field overriding and Scala.
This program will show what will be the output if override keyword is not used?
class animal{
val voice = "animal's voice"
}
class dog extends animal{
val voice = "Dog bark's...!"
def says(){
println(voice)
}
}
class cat extends animal{
val voice = "cat meow's...!";
def says(){
println(voice)
}
}
object MainObject{
var ani = new dog()
ani.says()
}
}
Output
error: overriding value voice in class animal of type String;
value voice needs `override' modifier
val voice = "Dog bark's...!"
^

Unit-II
error: overriding value voice in class animal of type String;
value voice needs `override' modifier
val voice = "cat meow's...!";
^
two errors found
This program will show what will be the output if override keyword is used?
class animal{
val voice = "animal's voice"
}
override val voice = "Dog bark's...!"
def says(){
println(voice)
}
}
override val voice = "Cat meow's...!";
def says(){
println(voice)
}
}
object MainObject{
var ani = new dog()
ani.says()
var ani2 = new cat()
ani2.says()
}
}
Output
Dog bark's...!
Cat meow's...!
3) Python program with var keyword
This program will show what will be the output if var keyword is used?
class animal{
var voice = "animal's voice"

Unit-II
}
override var voice = "Dog bark's...!"
def says(){
println(voice)
}
}
override var voice = "Cat meow's...!";
def says(){
println(voice)
}
}
object MainObject{
var ani = new dog()
ani.says()
var ani2 = new cat()
ani2.says()
}
}
Output
error: overriding variable voice in class animal of type String;
variable voice cannot override a mutable variable
override var voice = "Dog bark's...!"
^
error: overriding variable voice in class animal of type String;
variable voice cannot override a mutable variable
override var voice = "Cat meow's...!";
^
two errors found
2.7 Extending a class
You can extend a base Scala class and you can design an inherited class in the same way you do it
in Java (use extends key word), but there are two restrictions: method overriding requires the
override keyword, and only the primary constructor can pass parameters to the base constructor.
Let us extend our above class and add one more class method.
Example

Unit-II
Let us take an example of two classes Point class (as same example as above) and Location class
is inherited class using extends keyword. Such an ‘extends’ clause has two effects: it makes
Location class inherit all non-private members from Point class, and it makes the type Location a
subtype of the type Point class. So here the Point class is called superclass and the class Location
is called subclass. Extending a class and inheriting all the features of a parent class is called
inheritance but Scala allows the inheritance from just one class only.
Note − Methods move() method in Point class and move() method in Location class do not
override the corresponding definitions of move since they are different definitions (for example,
the former take two arguments while the latter take three arguments).
class Point(val xc: Int, val yc: Int) {
var x: Int = xc
var y: Int = yc
def move(dx: Int, dy: Int) {
x = x + dx
y = y + dy
println ("Point x location : " + x);
println ("Point y location : " + y);
}
}
class Location(override val xc: Int, override val yc: Int,
val zc :Int) extends Point(xc, yc){
var z: Int = zc
def move(dx: Int, dy: Int, dz: Int) {
x = x + dx
y = y + dy
z = z + dz
println ("Point x location : " + x);
println ("Point y location : " + y);
println ("Point z location : " + z);
}
}
object Demo {
val loc = new Location(10, 20, 15);
// Move to a new location

Unit-II
loc.move(10, 10, 5);
}
}
2.8 Implicit Classes
 Implicit classes allow implicit conversations with class’s primary constructor when the
class is in scope. Implicit class is a class marked with ‘implicit’ keyword. This feature is
introduced in Scala 2.10.

Syntax − The following is the syntax for implicit classes. Here implicit class is always in the
object scope where all method definitions are allowed because implicit class cannot be a top level
class.
Syntax
object <object name> {
implicit class <class name>(<Variable>: Data type) {
def <method>(): Unit =
}
}
Example
Let us take an example of an implicit class named IntTimes with the method times(). It means the
times () contain a loop transaction that will execute the given statement in number of times that
we give. Let us assume the given statement is “4 times println (“Hello”)” means the println
(“”Hello”) statement will execute 4 times.
The following is the program for the given example. In this example two object classes are used
(Run and Demo) so that we have to save those two classes in different files with their respective
names as follows.
Run.scala − Save the following program in Run.scala.
object Run {
implicit class IntTimes(x: Int) {
def times [A](f: =>A): Unit = {
def loop(current: Int): Unit =
if(current > 0){
f
loop(current - 1)
}

Unit-II
loop(x)
}
}
}
Demo.scala − Save the following program in Demo.scala.
import Run._
object Demo {
4 times println("hello")
}
}
The following commands are used to compile and execute these two programs.
Command
>scalac Run.scala
>scalac Demo.scala
>scala Demo
Output
Hello
Hello
Hello
Hello
2.9 Inner Classes
Inner Class is a special concept in Scala using which we can create a class inside another class.
It is used for grouping together classes to improve the usability of the concept of encapsulation in
Scala.
Though Scala inherits many features from Java but, the binding of inner classes. The inner class
in Scala is bound to outer object.
In Scala, they can be different types of inner class definitions,
1. Creating a class inside another class
2. Creating a class inside an object
3. Creating an object inside a class

Unit-II
1) Creating a class inside another class
We can define a class inside another class. Accessing the inner class member will require creating
the object of inner class using the object of outer class.
Syntax:
class outerClass{
class innerClass{
// members of innerClass
}
}
Program:
Illustrating the working of the inner class, creating a class inside another class,
// Illustrating the working of inner class
class outerClass{
class innerClass{
def printVal() {
println("This is inner Class from Outer Class!")
}
}
}
object myObjects {
val outObj = new outerClass()
val inObj = new outObj.innerClass
inObj.printVal
}
}
Output:
This is inner Class from Outer Class!
2) Creating a class inside an object
We can define a class inside an Object. And accessing class needs object for creation.
Syntax:
new outerObject.innerClass().member
Program:
// Illustrating the working of inner class,
// Creating inner class inside outer Object...

Unit-II
object OuterObject{
class innerClass{
def printVal() {
println("This is inner Class from Outer Object!")
}
}
}
object myObjects {
val inObj = new OuterObject.innerClass()
inObj.printVal
}
}
Output:
This is inner Class from Outer Object!
3) Creating an object inside a class
We can define an Object inside a class in Scala. And accessing object needs to create object of the
outerClass.
Syntax:
new outerClass().innerObject.member
Program:
// Illustrating the working of inner class,
// Creating inner object inside outer class...
class outerClass{
object innerObject{
def printVal() {
println("This is inner Object from Outer Class!")
}
}
}
object myObjects {
val inObj = new outerClass().innerObject

Unit-II
inObj.printVal
}
}
Output:
This is inner Object from Outer Class!
2.10 Traits
 Traits in Scala are like interfaces in Java. A trait can have fields and methods as members,
these members can be abstract and non-abstract while creation of trait.
The implementation of Scala traits can implement a trait in a Scala Class or Object.
Some features of Scala traits:
 Members can be abstract as well as concrete members.
 A trait can be extended by another trait.
 Made using "trait" keyword.
Syntax:
trait trait_name{
def method()
}
Example showing the use of trait
trait Iterator[A] {
def hasNext: Boolean
def next(): A
}
class IntIterator(to: Int) extends Iterator[Int] {
private var current = 0
override def hasNext: Boolean = current < to
override def next(): Int = {
if (hasNext) {
val t = current
current += 1
t
} else 0
}
}
val iterator = new IntIterator(10)
iterator.next() // returns 0
iterator.next() // returns 1

Unit-II
This example shows the use of trait and how it is inherited? The code creates a trait name Iterator,
this trait there are 2 abstract methods hasNext and next. Both the methods are defined in the class
IntInterator which defines the logic. And then creates objects for this class to use the trait
function.
Another working example,
trait hello{
def greeting();
}
class Ihelp extends hello {
def greeting() {
println("Hello! This is include Help! ");
}
}
object MyClass {
var v1 = new Ihelp();
v1.greeting
}
}
Output
Hello! This is include Help!
This code prints "Hello! This is include Help!" using trait function redefinition and then calling
that function.
Some pros and cons about using traits
 Traits are a new concept in Scala so they have limited usage and less interoperability. So,
for a Scala code That can be used with a Java code should not use traits. The abstract class
would be a better option.
 Traits can be used when the feature is to be used in multiple classes, you can use traits
with other classes too.
 If a member is to be used only once then the concrete class should be used rather than a
Traits it improves the efficiency of the code and makes it more reliable.
2.11 Pattern Matching
Scala pattern matching: pattern matching feature is check for the equivalence of an object with a
string. In Scala pattern matching classes are strong.

Unit-II
Matching a pattern contains a sequence of alternative of the pattern to be considered. Each
sequence is a case of the Scala pattern matching. For all alternatives, the case has expressions
which are evaluated for matching pattern matches. The arrow symbol '=>' is used as a separator
between the patterns and expressions.
The match keyword is used to define a pattern matching block. This block contain cases that are
that turns that if matched will execute a set of expressions (a block of code).
In Pattern matching, there must be at least one case (also called alternative) with sum values for
which the input pattern can be matched. If no keyword is matched then the last catch-all(_) case
is executed. The expression that is evaluated after the matches found is actually a block code that
is needed to be Evaluated. For a pattern-matching function, any sort of data can be matched
based on first match policy (for you cases matching, the first one is used).
Example:
object Demo {
def matchno(x: Int): String = x match {
case 1 => "Hello"
case 2 => "Welcome"
case _ => "to Scala "
}
println(matchno(3))
}
}
Matching using Case Classes
The case classes are special classes that are used in pattern matching with case expressions.
Syntactically, these are standard classes with a special modifier: case.
Try the following, it is a simple pattern matching example using case class.
Example
object Demo {

Unit-II
val alice = new Person("Alice", 25)
val bob = new Person("Bob", 32)
val charlie = new Person("Charlie", 32)
for (person <- List(alice, bob, charlie)) {
person match {
case Person("Alice", 25) => println("Hi Alice!")
case Person("Bob", 32) => println("Hi Bob!")
case Person(name, age) => println(
"Age: " + age + " year, name: " + name + "?")
}
}
}
case class Person(name: String, age: Int)
}
Adding the case keyword causes the compiler to add a number of useful features automatically.
The keyword suggests an association with case expressions in pattern matching.
 First, the compiler automatically converts the constructor arguments into immutable
fields (vals). The val keyword is optional. If you want mutable fields, use the var
keyword. So, our constructor argument lists are now shorter.
 Second, the compiler automatically implements equals, hashCode, and toString methods
to the class, which use the fields specified as constructor arguments. So, we no longer
need our own toString() methods.
 Finally, also, the body of Person class becomes empty because there are no methods that
we need to define!
2.12 Extractors
An extractor is a special type of object that has some special methods. These methods are:
apply() and unapply().

Unit-II
 The apply() method of extractor object is used to feeding values for the object, it takes
parameter values, formats them and adds them to the object.
 The unapply() method of extractor object is used to delete values from the object, it
matches the value and removes them from the object list.
Working of extractors
Let's take an example of an object that apply() as well as unapply() method. The apply() method
takes arguments and adds them to class. The unapply() does the exact opposite, it takes
arguments, matches them and then deletes, i.e. deconstructs.
Program:
object Student
{
{
def apply(name: String, result: String) =
{
name +" is "+ result
}
def unapply(x: String): Option[(String, String)] =
{
val y = x.split("is")
if (y.length == 2 && y(1)=="Pass")
{
Some(y(0), y(1))
}
else
None
}
println ("The Apply method returns : " +
apply("Ram", "Pass"))
println ("The Unapply method returns : " +
unapply("RamisPass"))
}
}

Unit-II
2.13 Collection Classes
 A collection in programming is a simple object used to collect data. It groups together
elements into a single entity (object). You can do the operation is to add, delete, update
data using collections.
 In Scala, there is a huge base of collection libraries. There is a wide hierarchy of
collections in Scala. Basic collections contain linear sets.
 The collection in Scala can be mutable as well as immutable.
A mutable collection is a collection whose elements can be updated and elements are added or
removed from it. It allows all these operations.
An immutable collection does not allow the user to do the update operation or add and remove
operation on it. There is an option to do this, but on every operation, a new collection is created
with updated value and the old one is discarded.
Based on how they have used the collections are classified as lazy or strict. If created as a lazy
collection, it may not consume memory space until they are called by the program.
As the hierarchy is concerned, we have a list of collections, with Traversable trait, it allows
you to traverse the collection i.e. visit each element in the collection one by one. Traversable
has followed another trait Iterable that allows iterating over the elements of the collection.
Here we are listing some commonly used collections that you will encounter in your Scala
programming life. There is a huge base that supports them, this is just an overview;
Scala List
The list is a linear array-like collection. It stores a similar type of elements and uses a linked
list type storage method. List is an immutable collection that extends linearSeq trait.
Scala Tuple
Tuple in Scala is an immutable collection. It can contain a fixed number of elements of
different types i.e. it can hold an integer and string together.
Scala Set
A set is a type collection that contains elements of the same data type, it does not contain any
duplicate elements. Set can mutable as well as immutable in Scala.
Scala Map
A map is a collection that contains key-value pairs. To retrieve the value the key is used.

Unit-II

Unit 2 notes.pdf

Recommended

Recommended

More Related Content

Similar to Unit 2 notes.pdf

Similar to Unit 2 notes.pdf (20)

More from Revathiparamanathan

More from Revathiparamanathan (18)

Recently uploaded

Recently uploaded (20)

Unit 2 notes.pdf