This is an art; each designer uses different techniques to
identify classes. However according to Object Oriented Design Principles, there
are five principles that you must follow when design a class,
SRP - The Single Responsibility Principle -
A class should have one, and only one, reason to change.
A class should have one, and only one, reason to change.
OCP - The Open Closed Principle -
You should be able to extend a classes behavior, without modifying it.
You should be able to extend a classes behavior, without modifying it.
LSP - The Liskov Substitution Principle-
Derived classes must be substitutable for their base classes.
Derived classes must be substitutable for their base classes.
DIP - The Dependency Inversion Principle-
Depend on abstractions, not on concretions.
Depend on abstractions, not on concretions.
ISP - The Interface Segregation Principle-
Make fine grained interfaces that are client specific.
Make fine grained interfaces that are client specific.
For more information on design principles, please refer to Object Mentor.
Additionally to identify a class correctly, you need to
identify the full list of leaf level functions/ operations of the system
(granular level use cases of the system). Then you can proceed to group each
function to form classes (classes will group same types of functions/
operations). However a well defined class must be a meaningful grouping of a
set of functions and should support the re-usability while increasing
expandability/ maintainability of the overall system.
In software world the concept of dividing and conquering is
always recommended, if you start analyzing a full system at the start, you will
find it harder to manage. So the better approach is to identify the module of
the system first and then dig deep in to each module separately to seek out
classes.
A software system may consist of many classes. But in any
case, when you have many, it needs to be managed. Think of a big organization,
with its work force exceeding several thousand employees (let’s take one
employee as a one class). In order to manage such a work force, you need to
have proper management policies in place. Same technique can be applies to
manage classes of your software system as well. In order to manage the classes
of a software system, and to reduce the complexity, the system designers use
several techniques, which can be grouped under four main concepts named
Encapsulation, Abstraction, Inheritance, and Polymorphism. These concepts are
the four main gods of OOP world and in software term, they are called four main
Object Oriented Programming (OOP) Concepts.
Association is a (*a*) relationship between two classes,
where one class use another. But aggregation describes a special type of an
association. Aggregation is the (*the*) relationship between two classes. When
object of one class has an (*has*) object of another, if second is a part of
first (containment relationship) then we called that there is an aggregation
between two classes. Unlike association, aggregation always insists a
direction.
In this case I can say that University aggregate Chancellor
or University has an (*has-a*) Chancellor. But even without a Chancellor a
University can exists. But the Faculties cannot exist without the University,
the life time of a Faculty (or Faculties) attached with the life time of the
University . If University is disposed the Faculties will not exist. In that
case we called that University is composed of Faculties. So that composition
can be recognized as a special type of an aggregation.
So in summary, we can say that aggregation is a special kind
of an association and composition is a special kind of an aggregation.
(Association->Aggregation->Composition)


No comments:
Post a Comment