Object Oriented Design Principles are core of OOPS programming but I have seen most of Java programmer chasing design patterns like Singleton pattern , Decorator pattern or Observer pattern but not putting enough attention on Object oriented analysis and design or following these design principles. I have regularly seen Java programmers and developers of various experience level who either doesn't heard about these OOPS and SOLID design principle or simply doesn't know what benefits a particular design principle offers or how to use these design principle in coding.
Bottom line is always strive for highly cohesive and loosely couple solution, code or design and looking open source code from Apache and Sun are good examples of Java design principles or how design principles should be used in Java coding. Java Development Kit follows several design principle like Factory Pattern in BorderFactory class, Singleton pattern in Runtime class and if you interested more on Java code read Effective Java by Joshua Bloch , a gem by the guy who wrote Java API. My another personal favorite on object oriented design pattern is Head First Design Pattern by Kathy Sierra and others and Head First Object Oriented Analysis and Design .
Though best way of learning design principles or pattern is real world example and understanding the consequences of violating that design principle, subject of this article is Introducing Object oriented design principles for Java Programmers who are either not exposed to it or in learning phase. I personally think each of these design principle
need an article to explain it clearly and I will definitely try to do
it here but for now just get yourself ready for quick bike ride on
design principle town :)
Though best way of learning design principles or pattern is real world example and understanding the consequences of violating that design principle, subject of this article is Introducing Object oriented design principles for Java Programmers who are either not exposed to it or in learning phase. I personally think each of these design principle
need an article to explain it clearly and I will definitely try to do
it here but for now just get yourself ready for quick bike ride on
design principle town :)Object oriented design principle 1 - DRY (Don't repeat yourself)
As name suggest DRY (don't repeat yourself) means don't write duplicate code, instead use abstraction
to abstract common things in one place. if you use a hardcoded value
more than one time consider making it public final constant, if you have
block of code in more than two place consider making it a separate
method. Benefit of this SOLID design principle is in maintenance. Its
worth to note is don’t abuse it, duplicate is not for code but for
functionality means if you used common code to validate OrderID and SSN
it doesn’t mean they are same or they will remain same in future. By
using common code for two different functionality or thing you closely
couple them forever and when your OrderID changes its format , your SSN
validation code will break. So beaware of such coupling and just don’t
combine anything which uses similar code but are not related.
Object oriented design principle 2 - Encapsulate what varies
Only
one thing is constant in software field and that is "Change", So
encapsulate the code you expect or suspect to be changed in future.
Benefit of this OOPS Design principle is that Its easy to test and maintain proper encapsulated code. If you are coding in Java then follow principle
of making variable and methods private by default and increasing access
step by step e.g. from private to protected and not public. Several of design pattern in Java uses Encapsulation, Factory design pattern
is one example of Encapsulation which encapsulate object creation code
and provides flexibility to introduce new product later with no impact
on existing code.
Object oriented design principle 3 - Open Closed principle
Classes, methods or functions should be Open for extension (new functionality) and Closed for modification. This is another beautiful object oriented design principle
which prevents some-one from changing already tried and tested code.
Ideally if you are adding new functionality only than your code should be tested and that's the goal of Open Closed Design principle.
Object oriented design principle 4 - Single Responsibility Principle (SRP)
There
should not be more than one reason for a class to change or a class
should always handle single functionality. If you put more than one
functionality in one Class in Java it introduce coupling
between two functionality and even if you change one functionality
there is chance you broke coupled functionality which require another
round of testing to avoid any surprise on production environment.
Object oriented design principle 5 - Dependency Injection or Inversion principle
Don't
ask for dependency it will be provided to you by framework. This has
been very well implemented in Spring framework, beauty of this design principle
is that any class which is injected by DI framework is easy to test
with mock object and easier to maintain because object creation code is
centralized in framework and client code is not littered with that.There
are multiple ways to implemented Dependency injection like
using byte code instrumentation which some AOP (Aspect Oriented
programming) framework like AspectJ does or by using proxies just like
used in Spring.
Object oriented design principle 6 - Favour Composition over Inheritance
Always favour composition over inheritance
if possible. Some of you may argue this but I found that Composition is
lot more flexible than Inheritance. Composition allows to change
behaviour of a class at runtime by setting property during runtime and
by using Interfaces to compose a class we use polymorphism which provides flexibility of to replace with better implementation any time. Even Effective Java advise to favor composition over inheritance.
Object oriented design principle 7 - Liskov Substitution Principle (LSP)
According to Liskov Substitution Principle
Subtypes must be substitutable for super type i.e. methods or functions
which uses super class type must be able to work with object of sub
class without any issue". LSP is closely related to Single responsibility principle and Interface Segregation Principle.
If a class has more functionality than subclass might not support some
of the functionality and does violated LSP. In order to follow LSP design principle, derived class or sub class must enhance functionality not reducing it.
Object oriented design principle 8 - Interface Segregation principle (ISP)
Interface Segregation Principle
stats that a client should not implement an interface if it doesn't use
that. this happens mostly when one interface contains more than one
functionality and client only need one functionality and not
other.Interface design is tricky job because once you release your
interface you can not change it without breaking all implementation.
Another benefit of this desing principle in Java is, interface has
disadvantage to implement all method before any class can use it so
having single functionality means less method to implement.
Object oriented design principle 9 - Programming for Interface not implementation
Always program for interface and not for implementation
this will lead to flexible code which can work with any new
implementation of interface. So use interface type on variables, return
types of method or argument type of methods in Java. This has been advised by many Java programmer including in Effective Java and head first design pattern book.
Object oriented design principle 10 - Delegation principle
Don't do all stuff by yourself, delegate it to respective class. Classical example of delegation design principle is equals() and hashCode() method in Java.
In order to compare two object for equality we ask class itself to do
comparison instead of Client class doing that check. Benefit of this
design principle is no duplication of code and pretty easy to modify behaviour.
All these object oriented design principle helps
you write flexible and better code by striving high cohesion and low
coupling. Theory is first step but what is most important is to develope ability to find out when and to apply these design principle
and find our whether we are violating any design principle and
compromising flexibility of code. but again as nothing is perfect in
this world, don't always try to solve problem with design patterns and design principle they are mostly for large enterprise project which has longer maintenance cycle.
Source:http://javarevisited.blogspot.com/2012/03/10-object-oriented-design-principles.html
Source:http://javarevisited.blogspot.com/2012/03/10-object-oriented-design-principles.html
