OO Design: S.O.L.I.D principles

Technical teamDNB 2015

Page 1Confidential

Presenters: Quang Nguyen, Lan Nguyen

Page 2Confidential

OutlineSOLID principles introductionPurpose of use.Definition, explanation, examples and benefits of

+ Single responsibility principle (SRP) + Open – close Principle (OCP) + Linkov's substitution principle (LSP) + Interface segregation principle (ISP) + Dependency inversion principle (DIP)

ConclusionQ&A

Page 3Confidential

Design Matter: Doing Better with Less

Introduction

Page 4Confidential

S.O.L.I.D is an acronym for the first five object-oriented design(OOD) principles by Robert C. Martin, popularly known as Uncle Bob.

S – Single Responsibility principleO – Open-closed principleL – Liskov’s substitution principleI – Interface segregation principleD – Dependency Inversion principle

What are the issues that developers always face to in software development lifecycle?

Question

Requirements change

Page 6Confidential

Your requirements will always change (and grow) over time

Your system need to evolve to handle the changes.We should build a software which is smartly designed

enough to change..

What is “Smartly-designed Software” ?

Page 7Confidential

Handle the changes with minimal re-factor and effort.ExtendableReusableFlexible

Customer and Developer satisfaction

Page 8Confidential

Customers are satisfied because the software:+ Work well + Keeps working - always.+ Can be changed, upgraded easily+ Reuse to build other software.+ Extendable, Flexible.

Help the developers:+ Handle the changes easily.+ Code better in any programming languages.

Page 9Confidential

PURPOSE OF USE

When combined together, these principles will help your software: Become well and smartly-designed Easily handle the changes Make both customer and developer satisfied with their work.Save money and time.

Single Responsibility principle (SRP)

Page 10Confidential

SRP - Definition

Page 11Confidential

“An object should have one and only one reason to change”

SRP - Explanation

Page 12Confidential

Responsibility is a family of functions that serves one particular purpose.If you have a class having more than one reason to change=> you should split the class into multiple classes base on their responsibilities.

SRP - Example

Page 13Confidential

SRP – Why splitting is important ?

Page 14Confidential

- If classes have more than one responsibility ?- Each responsibility is an axis of change.

+ Codes become complicated+ One change effects another

- Big classes:+ Difficult to change+ Harder to read

+ Bugs

SRP – Benefit

Page 15Confidential

Increase the reusability of source codeMake your classes smaller, lesser complicated.Restrict effects to other modules when we change

source codes.Easier to read and write => less to write bugs.Higher cohesion, lower coupling.

Smaller classes and smaller methods will give you more flexibility

More classes != more complicated

Open – Close Principle (OCP)

Page 16Confidential

OCP - Definition

Page 17Confidential

“An object should be opened for extension and closed for modification”

OCP - Explanation

Page 18Confidential

- You should extend a class without modifying it. - if you read and understand all source code to find

what they are supposed to do and update. so hard cost time, effort bugs

- But it’s easy to extend the source code to meet the new requirements.

OCP - Example

Page 19Confidential

OCP – Benefit

Page 20Confidential

- Restrict effects to others because when you change code.- Not need to read all old source codes that already worked well.- Extend the existing libraries.

- Template Method Design Pattern- Strategy Design Pattern.

Reference

Liskov's Substitution (LSP) - Definition

Page 22Confidential

“Objects should be replaceable with their base classes without altering the correctness of the program”

LSP - Explanation

Page 23Confidential

+ Should always use a base class or interface instead of the subclasses. + This works correctly with any subclasses of X.

Extends without replacing any base class's functions

LSP - Example

Page 24Confidential

LSP – Benefit

Page 25Confidential

- This is an extension of OCP Wrong LSP => wrong OCP Inherit all OCP's benefits.- Preventing bugs caused by subclasses.

Interface segregation Principle (ISP)

Page 26Confidential

ISP - Definition

Page 27Confidential

“A client should not implement an interface, if it doesn't use that”

ISP - Explanation

Page 28Confidential

Clients should not be forced to implement interfaces they don't use

=> Split a fat interface which has many methods into many small interfaces.

ISP - Example

Page 29Confidential

ISP – Benefit

Page 30Confidential

- Smaller interface => more reusable - Extendable - Flexible - Allows people to use only the parts of objects that they need. - High cohesion, low coupling - Comply SRP.

Dependence Inversion Principle (DIP)

Page 31Confidential

DIP - Definition

Page 32Confidential

“High level model should not depend on low level module, both should depend on abstractions

Abstractions should not depend on details. Details should depend on abstractions”

DIP - Explanation

Page 33Confidential

- Low level module: implement basic and primary operations- High level module: encapsulate complex logic- The high level classes should not directly use and heavily depend on low level classes.=> we should create abstraction layer between high level classes and low level classes

DIP - Example

Page 34Confidential

Demo - Explanation

Page 35Confidential

DIP - Explanation

Page 36Confidential

- Abstractions should not depend upon details- Details should depend on abstractions

Page 37Confidential

- Spring frameworks' component

- Using Dependency Injection pattern

- Automatic class instantiation (from external files or annotation)

- Entirely remove the low-level component dependencies and achieve true DIP.

IoC Container & Dependency Injection

DIP – Benefit

Page 38Confidential

- Reusable- Flexible- More readable.- Higher cohesion - lower coupling- Remove dependencies between low and high level

modules.- Violate DIP => Violate OCP or LSP.- More classes != More complicated

Should we always apply DIP anywhere?Question

Conclusion

Page 40Confidential

With S.O.L.I.D principles, our software: Easily handle the changes Become well and smartly-designed Make both customer and developer satisfied with their work.Save money and time.

OOP vs OOD

Page 41Confidential

Object oriented design (OOD) = OOP + Design principles.The source code applied OOD will be:+ Object oriented+ Re-usable+ Flexible: can be changed with minimal efforts.+ Extendable: can be extended without changing existing

codes

Q&A

Page 42Confidential

References

Page 43Confidential

http://www.oodesign.com/

http://www.codeproject.com/Articles/703634/SOLID-architecture-principles-using-simple-Csharp

https://scotch.io/bar-talk/s-o-l-i-d-the-first-five-principles-of-object-oriented-design

Object oriented analysis and design book by Head First

Design pattern

Dependency Injection and IoC container in Spring Framework