Башкирцев (Старовер) Станислав JavaTalks OOD Principles

2 План презентации Intro Don’t Repeat Yourself Open Closed Single Responsibility Interface Segregation Inversion of Control Liskov’s Substitution Q/A

3 OOD Principles. What’s that? Recipes, best practices how to write Clean, easy to understand code Maintainable (flexible, extendable) code

DRY Don’t Repeat Yourself Don’t duplicate code

5 Without DRY

If something changes?

With DRY

If something changes?

DRY Don’t Repeat Yourself Don’t duplicate code Names should be clear

Not clear names 1. No one would guess to look sorting method in this class. 2. Newbie always would write his own implementation.

Correct DRY clear, well-defined class names

DRY Don’t Repeat Yourself Don’t duplicate code Names should be clear Location should be clear

Not clear location No one would look for array utilities in such package

DRY. Pros & Cons Pros: Changes impact local area Once written is not repeated No ”new” error prone solutions Cons: Amount of classes grows

OCP Open Closed Principle - code should be closed for modification, but open for extension.

OCP. Example I want my clients to be able to see results of past games. Let’s keep up with NHL & NBA games.. 1. American customer 2. His thoughts 3. His ill imagination

OCP. Example Base class Creates specific objects according to...

OCP. Example Great! A lot of new clients, a lot of money from ads. But.. Would be great if my cliends would be able to get info about MLB games too!

OCP. Example New league was added We are changing already working class!

OCP. Example Why my clients see errors on every page?!! I pay you for work, not for errors! I loose my clients, make the program work right!

OCP. Example Element of array is compared with league name – NPE is possible!

OCP. Moral This example shows that changing code that already works is always bad idea. Follow OCP to escape this!

OCP. Example MlbSportInfoBuilder NbaSportInfoBuilder NhlSportInfoBuilder

OCP. Example Great! You job satisfies me! But now I want WNBA to be added

OCP. Example MlbSportInfoBuilder NbaSportInfoBuilder NhlSportInfoBuilder WnbaSportInfoBuilder New league was added without changing single line of code!

OCP. How it works OCP uses: Delegation Inheritance

OCP. Pros & Cons Pros: Adding new functionality without legacy code being changed Cons: May complicate system because of amount of classes being grown

SRP Single Responsibility Principle: Single class should have a single responsibility Class should have only one reason to change

SRP. Random thoughts Hm.. Strange that inflation is counted in CurrencyConverter.. Hm.. What if format of currency service changes? What if the format of inflation service changes? We’ll have to change this class in both cases! It’s not intuitive! It’s overloaded! We have to do something!

SRP. Separate Responsibilities Hm.. What if format of currency service changes? We change CurrencyConverter! Hm.. What if format of inflation service changes? We change InflationIndexCounter!

SRP & DRY Again two responsibilities: Authentication & getting user from database DRY violation!

SRP. Delegating responsibilities Now we don’t work directly with database! If we would want to use ORM, UserAuthenticator won’t change!

SRP. Pros & Cons Pros: Helps to follow DRY Lowers chances to change single class Class names correspond to what they do Cons: May complecate system by adding too much new classes

ISP Interface Segregation Principle – client code shouldn’t be obligated to depend on interfaces it doesn’t use.

ISP. Example Base interface of the person. All these methods are useful for current implementation of person.

ISP. Extra methods But we’re writting new module that considers a person only as a human being. So we need only one method eat() So our new implementation has two extra methods.

ISP. What these methods do?!

ISP. Fat/Polluted Interfaces It’s fat It’s POLLUTED

ISP. Interface Separating We separated Person into Person & Worker. Two conceptually different interfaces.

ISP. No extra methods Now we have only needed methods.

ISP. Legacy code What if we have ready implementation, but we don’t want to use fat interface?

ISP. Use Adapters Thin interface Fat interface

ISP. Pros & Cons Pros: No need to implement unnecessary methods Client code sees only what it should see Cons: Adding additional interfaces

IoCP Invertion of Control Principle says: Code to abstraction, not to implementation Objects that use other objects, shouldn’t create latter ones

IoCP. Coding to implementation

IoCP. How to test Crawler? It’s impossible to write unit test for Crawler, because you cannot mock parser.

IoCP. Let’s inject Now you can specify parser through constructor. You can inject dummy object while testing.

IoCP. Again doesn’t work Your parser doesn’t work with HTML that isn’t a valid XML!

IoCP. New Implementation HtmlParser DomBasedHtmlParser EnhancedHtmlParser

IoCP. But how do we replace? We cannot specify another implementaion!

IoCP. Let’s code to interface Now we use interface, so we can specify enhanced implementation of parser.

IoCP. Another look How do we inject objects if we work on framework/library? We cannot use IoC Containers, our clients don’t allow us extra dependencies, they don’t want to depend on Spring or Guice. We need leightweight decision.

IoCP. Let’s use Factories Let’s use Factories! Hm.. But we cannot write unit tests again!

IoCP. Let’s mix We have both: setter and factory in the same class. Now we have default implementation and possibility to change default behavior.

IoCP. Pros & Cons Pros: Classes don’t depend on concrete implementation Allows easily change implementation Allows write good unit tests Cons: Creating additional interfaces Creating Factories/depending on IoC containers

LSP Liskov’s Substitution Principle – derived types must be completely substitutable for their base types. LSP declares how to use inheritance correctly.

LSP. java.util.List Would be strange if these implementation would do different things here

LSP. Emu doesn’t fly! But emu doesn’t fly!

LSP. Emu indeed doesn’t fly Simply birds. Flying birds. Emu is simply a bird. It doesn’t have extra methods.

LSP. Array example Default implementation. It’s a temporal class that uses unefficient approach. But it does it’s work correctly.

LSP. Array example At last we wrote enhanced implementation that’s really efficient.

LSP. Again bugs! Your system always throws errors! It’s a chaos!!

LSP. Array example It sorts the original array! We have problems with synchronization. Implementation does its work, but it has side effects. It doesn’t satisfy interface contract! We cannot simply replace one implementation with another one, because they differ! We should correct its behaviour to copy original array and work with its copy.

LSP & equals() Colored point extends simple point and adds new field – color. But it works only with ColoredPoint!

LSP & equals This will print: true false This violates equals() contract! There is no correct dicision in this situation!

LSP & equals() The only correct way here is to use delegation instead of inheritance.

LSP & exceptions What if this method in our implementation threw IOException? How would we know about that? We work with interface List, not with implementation! That’s why Java doesn’t allow us to throw any checked exception that are not declared in base class.

LSP. Pros & Cons Pros: Allows not to think about concrete implementation, but code to abstraction Unambiguously defines contract all implementers should follow Allows to interchange implementation correctly, without side effects

The End Q/A