Putting Design Principles to the Test
(A Java based Case Study)
by: Samudra Gumpta
It's time to consolidate on what we've
been discussing in this series about design principles governing
the class structure and package structure. In this article, I
will present a sample case study in which we will develop a
hypothetical application component and try to employ all the
design principles we have learned so far, to come up with a
reasonable robust design solution. You can appreciate that it is
well beyond the scope of the space for this article to present a
large-scale project architecture encompassing all the
complexities that can arise in a designing situation. So, I will
try to pick a hypothetical application component and try to
present a design for that component module. Well then, have your
cup of coffee ready with you.
Reprise of what we have discussed
In the previous five articles, I have presented the design
principles governing the class structure and packaging of
several classes into different packages. In this section, we
will recapitulate the principles that we have discussed so far.
Design Principles for Class Structure
Principle 1: Open Closed Principle (OCP)
A software module should be closed for modification but
open for extension.
Principle 2: Liskov’s Substitution Principle (LSP)
If for each object o1 of type S there is an object o2 of
type T such that for all programs P defined in terms of T, the
behavior of P is unchanged when o1 is substituted for o2 then S
is a subtype of T.
Principle 3: Dependency Inversion Principle (DIP)
- High-level modules should not
depend upon low-level modules. Both should depend upon abstractions.
- Abstractions should not
depend upon details. Details should depend upon abstractions.
Principle 4: Composite Reuse Principle (CRP)
Favor composition over inheritance to achieve
polymorphism.
Principle 5: Interface Segregation Principle (ISP)
Many specific interfaces are better than one combined
general interface.
Design Principles for Package Structure
Principle 1: Release Reuse Equivalency Principle (REP)
The granule of release is the granule of reuse.
Principle 2: Common Reuse Principle (CReP)
The classes in a package are reused together. If one of the
classes in a package is reused, all the classes in that package
are reused.
Principle 3: Common Closure Principle (CCP)
Classes that change together must be placed in the same
package.
Principle 4: Acyclic Dependency Principle (ADP)
The dependencies between packages must form no cycles.
Principle 5: Stable Dependencies Principle (SDP)
The dependencies between packages must always be in the
direction of stability. Less stable packages should depend on
more stable packages.
Principle 6: Stable Abstraction Principle (SAP)
The stable packages must be abstract packages. The
instable packages should contain the concrete implementations.
New on the Java Boutique:
New Review:
Time Management Made Easy with the Quartz Enterprise Job Scheduler
Why not just use the Java timer API? This open source scheduling
API boasts simplicity, ease-of-integration, a well-rounded feature
set, and it's free!
New Applet:
Reverse Complement
Reverse Complement is a simple applet that converts DNA or RNA
sequences into three useful formats.
Elsewhere on internet.com:
WebDeveloper Java
Lots of Java information on webdeveloper.com
WDVL Java
Thorough Java resource at the Web Developer's Virtual Library.
ScriptSearch Java
Hundreds of free Java code files to download.
jGuru: Your View of the Java Universe
Customizable portal with online training, FAQs, regular news updates, and tutorials.
| 
