OOPs Development with Scala

Introduction to

Object Oriented Programming

Mumbai

What is an object?

Dog

Snowy

Dog is a generalization of Snowy

Dog

Animal

Snowy

Subclass?

Dog

Animal

Bird

Polymorphism?

object

Real world abstractions

Encapsulate state
represent information
state
Communicate by
Message passing
behavior
May execute in sequence
Or in parallel

name

state

behavior

inheritance encapsulation

Building
blocks polymorphism

Inheritance lets you build classes based on other
classes, thus avoiding duplicating and repeating
code

When a class inherits from another,
Polymorphism allows a subclass to standin for a
superclass

duck

cuckoo
Bird.flapWings()

ostrich

Encapsulation is to hide the internal
representation of the object from view outside
object definition

Car.drive()
Car

drive()

camry
car
accord

Vehicle toyota
motorcycle

honda Harley-davidson

civic
corolla

5 mins

Object Oriented
Solutions

for

What the stakeholders
want

1

Add flexibility,
Remove duplication
Encapsulation,
2 Inheritance,
Polymorphism

3

Apply patterns
Loose coupling
Delegation

We have a product which collects checks from
various banks and processes them.
The process includes sending out email, a fax or
storing a scan for the check.

Pay attention to the nouns (person, place or thing)
they are object candidates

The verbs would be the possible methods

This is called textual analysis

We have a product which collects checks from
various banks and processes them.
The process includes sending out email, a fax or
storing a scan for the check.

5 mins

FastProcessor

process(check:Check) Bank
sendEmail(check:Check)
sendFax(check:Check)
scan(check:Check)
*
Check
----------------
bank:Bank

case class Bank(id:Int, name:String)
case class Check(number:Int, bank:Bank)

class FastProcessor {

def process(checks:List[Check]) = checks foreach (check => sendEmail)

def sendEmail = println("Email sent")

}

val citibank = new Bank(1, "Citibank") //> citibank :
com.baml.ooad.Bank = Bank(1,Citibank)
(new FastProcessor).process(List(new Check(1,citibank), new Check(2,citibank)))
//> Email sent
//| Email sent

We need to support BoA as well and that sends
Faxes

case class Bank(id:Int, name:String)
case class Check(number:Int, bank:Bank)


def process(checks:List[Check]) = checks foreach (check => if
(check.bank.name=="Citibank") sendEmail else sendFax)

def sendFax = println("Fax sent")

}

val citibank = new Bank(1, "Citibank") //
val bankOfAmerica = new Bank(2, "BoA")
//
val citibankCheckList = List(new Check(1,citibank), new Check(2,citibank))
val bankOfAmericaCheckList = List(new Check(1,bankOfAmerica), new
Check(2,bankOfAmerica))

(new FastProcessor).process(citibankCheckList ::: bankOfAmericaCheckList)
//> Email sent
//| Email sent
//| Fax sent
//| Fax sent

We need to support HDFC and ICICI as well now!

good design == flexible design

whenever there is a change encapsulate it

5 mins

trait Bank {
def process(check: Check)
}

object CitiBank extends Bank {
val name = "CitiBank"
def process(check: Check) = sendEmail

}

object BankOfAmerica extends Bank {
val name = "BoA"
def process(check: Check) = sendFax

}

object HDFC extends Bank {
val name = "HDFC"
def process(check: Check) = {sendFax; sendEmail}


}

case class Check(number: Int, bank: Bank)


def process(checks: List[Check]) = checks foreach (check =>
check.bank.process(check))

}

val citibankCheckList = List(new Check(1, CitiBank), new Check(2,
CitiBank))
val bankOfAmericaCheckList = List(new Check(1, BankOfAmerica), new
Check(2, BankOfAmerica))

val hdfcCheckList = List(new Check(1, HDFC))

(new FastProcessor).process(citibankCheckList :::
bankOfAmericaCheckList ::: hdfcCheckList)
//> Email sent
//| Email sent
//| Fax sent
//| Fax sent
//| Fax sent
//| Email sent

bank
FastProcessor

HDFC BoA Citibank

Check

Code to interfaces – makes software easy to
extend

Encapsulate what varies – protect classes from
changes

Each class should have only one reason to
change

What the stakeholders
want

1
Add flexibility,
Remove duplication
Encapsulation,
Inheritance,
2 Polymorphism

3

Apply patterns
Loose coupling
Delegation

OO Principles

result in maintenable, flexible and extensible
software

Open Closed Principle

Classes should be open for extension and closed
for modification

bank

HDFC BoA Citibank

Any number of banks?

DRY

Don't repeat yourself

All duplicate code should be encapsulated /
abstracted

bank
FastProcessor

HDFC BoA Citibank

Check

CommunicationUtils

Single Responsibility Principle

Each object should have only one reason to
change

What methods should really belong to
Automobile?

Liskov Substitution Principle

Subtypes MUST be substitutable for their base
types

Ensures well designed inheritance

class Rectangle {
var height: Int = 0
var width: Int = 0
def setHeight(h: Int) = { height = h }
def setWidth(w: Int) = { width = w }
}

class Square extends Rectangle {
override def setHeight(h: Int) = { height = h; width = h }
override def setWidth(w: Int) = { width = w; height = w }
}

val rectangle = new Square

rectangle.setHeight(10)
rectangle.setWidth(5)

assert(10 == rectangle.height) //>
java.lang.AssertionError: assertion failed

There are multiple options other than

inheritance

Delegation

When once class hands off the task of doing
something to another

Useful when you want to use the functionality of
another class without changing its behavior

bank

HDFC BoA Citibank

We delegated processing to individual banks

Composition and Aggregation

To assemble behaviors from other classes

HDFC BoA Citibank

CommunicationUtils

30 min Exercise

Design an OO parking lot. What classes and
functions will it have. It should say, full, empty
and also be able to find spot for Valet parking.
The lot has 3 different types of parking: regular,
handicapped and compact.

OOPs Development with Scala

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (20)

Similar to OOPs Development with Scala

Similar to OOPs Development with Scala (20)

More from Knoldus Inc.

More from Knoldus Inc. (20)

Recently uploaded

Recently uploaded (20)

OOPs Development with Scala