Getting started with OOPs and Scala in an Agile way

1. Introduction to
Object Oriented Programming
Mumbai

2. What is an object?
Dog
Snowy

3. Dog is a generalization of Snowy
Dog
Animal
Snowy
Subclass?

4. Dog
Animal
Bird
Polymorphism?

5. object
Real world abstractions
Encapsulate state
represent information
state
Communicate by
Message passing
behavior
May execute in sequence
Or in parallel

6. name
state
behavior

7. inheritance encapsulation
Building
blocks polymorphism

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

9. When a class inherits from another,
Polymorphism allows a subclass to standin for a
superclass
duck
cuckoo
Bird.flapWings()
ostrich

10. Encapsulation is to hide the internal
representation of the object from view outside
object definition
Car.drive()
Car
drive()

11. camry
car
accord
Vehicle toyota
motorcycle
honda Harley-davidson
civic
corolla
5 mins

12. Object Oriented
Solutions
for

13. What the stakeholders
want
1
Add flexibility,
Remove duplication
Encapsulation,
2 Inheritance,
Polymorphism
3
Apply patterns
Loose coupling
Delegation

14. 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.

15. 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

16. 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

17. 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.

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

19. object interactions

20. 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

21. We need to support BoA as well and that sends
Faxes

22. We dont touch the design

23. case class Bank(id:Int, name:String)
case class Check(number:Int, bank:Bank)
class FastProcessor {
def process(checks:List[Check]) = checks foreach (check => if
(check.bank.name=="Citibank") sendEmail else sendFax)
def sendEmail = println("Email sent")
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

24. We need to support HDFC and ICICI as well now!

25. good design == flexible design
whenever there is a change encapsulate it
5 mins

26. What the stakeholders
want
1
Add flexibility,
Remove duplication
Encapsulation,
2 Inheritance,
Polymorphism
3
Apply patterns
Loose coupling
Delegation

27. trait Bank {
def process(check: Check)
}
object CitiBank extends Bank {
val name = "CitiBank"
def process(check: Check) = sendEmail
def sendEmail = println("Email sent")
}
object BankOfAmerica extends Bank {
val name = "BoA"
def process(check: Check) = sendFax
def sendFax = println("Fax sent")
}
object HDFC extends Bank {
val name = "HDFC"
def process(check: Check) = {sendFax; sendEmail}
def sendEmail = println("Email sent")
def sendFax = println("Fax sent")
}
case class Check(number: Int, bank: Bank)

28. class FastProcessor {
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

29. bank
FastProcessor
HDFC BoA Citibank
Check

30. bank
FastProcessor
HDFC BoA Citibank
Check

31. Code to interfaces – makes software easy to
extend
Encapsulate what varies – protect classes from
changes
Each class should have only one reason to
change

32. What the stakeholders
want
1
Add flexibility,
Remove duplication
Encapsulation,
Inheritance,
2 Polymorphism
3
Apply patterns
Loose coupling
Delegation

33. OO Principles
result in maintenable, flexible and extensible
software

34. Open Closed Principle
Classes should be open for extension and closed
for modification

35. bank
HDFC BoA Citibank
Any number of banks?

36. DRY
Don't repeat yourself
All duplicate code should be encapsulated /
abstracted

37. bank
FastProcessor
HDFC BoA Citibank
Check
CommunicationUtils

38. What the stakeholders
want
1
Add flexibility,
Remove duplication
Encapsulation,
Inheritance,
2 Polymorphism
3
Apply patterns
Loose coupling
Delegation

39. Single Responsibility Principle
Each object should have only one reason to
change

41. What methods should really belong to
Automobile?

43. Liskov Substitution Principle
Subtypes MUST be substitutable for their base
types
Ensures well designed inheritance

44. Is this valid?

45. 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

46. There are multiple options other than
inheritance

47. 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

48. bank
HDFC BoA Citibank
We delegated processing to individual banks

49. Composition and Aggregation
To assemble behaviors from other classes

50. HDFC BoA Citibank
CommunicationUtils

51. 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.