U20CBT509

SOFTWARE DESIGN WITH UML

Course Objectives:
• To Understand the object-oriented software development
process
• To Design suitable pattern to develop software models
• To Analyze requirements to create requirements design model
• To Apply business modeling and modeling languages to design
software
• To Develop correct and robust software deployment models
Course Outcomes:

After completion of the course, the students will be able to

• CO1 - Decide a suitable software model for a project (K2)
• CO2 - Describe how to model object-oriented languages (K2)
• CO3 - Design a project business model (K3)
• CO4 - Elicit requirements and design a user interface model (K2)
• CO5 - Create a deployment model (K3)
UNIT II UML LANGUAGE AND DESIGN PATTERNS
• Standards
• Elements of the language.
• General description of various models
• The process of Object-Oriented Software development.
• Description of Design Patterns
• Technological Description of Distributed Systems.
The primary goals in the design of the UML were:
● Provide users with a ready-to-use, expressive visual modeling language so
they can develop and exchange meaningful models.
● Provide extensibility and specialization mechanisms to extend the core
concepts.
● Be independent of particular programming languages and development
processes.
● Provide a formal basis for understanding the modeling language.
● Encourage the growth of the OO tools market.
● Support higher-level development concepts such as collaborations,
frameworks, patterns and components.
● Integrate best practices.
Standard Elements of UML

two standard stereotypes that apply to active classes

1. Specifies a heavyweight flow that can execute concurrently with

other processes process
2. threadSpecifies a lightweight flow that can execute concurrently
with other threads with in the same process
A process is heavyweight, which means that it is a thing known to the
operating system itself and runs in an independent address space.

Processes are never nested inside one another. If the node has
multiple processors, then true concurrency on that node is possible.

If the node has only one processor, there is only the illusion of true
concurrency, carried out by the underlying operating system.
A thread is lightweight.
It may be known to the operating system itself.
More often, it is hidden inside a heavier-weight process and runs inside
the address space of the enclosing process.
In Java, for example, a thread is a child of the class Thread. All the
threads that live in the context of a process are peers of one another,
contending for the same resources accessible inside the process.
Threads are never nested inside one another. In general, there is only
the illusion of true concurrency among threads because it is processes,
not threads, that are scheduled by a node's operating system.
 General description of various models / UML
Models / UML Modelling
Types of UML modeling:
• Structural Modeling
• Behavioral Modeling
• Architectural Modeling
Structural Modeling
Structural modeling captures the static features of a system. They consist of the following
−
• Classes diagrams
• Objects diagrams
• Deployment diagrams
• Package diagrams
• Composite structure diagram
• Component diagram
Structural model represents the framework for the system and this framework is the place
where all other components exist. Hence, the class diagram, component diagram and
deployment diagrams are part of structural modeling. They all represent the elements and
the mechanism to assemble them.
The structural model never describes the dynamic behavior of the system. Class diagram
is the most widely used structural diagram.
Behavioral Modeling

Behavioral model describes the interaction in the system. It represents the

interaction among the structural diagrams. Behavioral modeling shows
the dynamic nature of the system. They consist of the following −

• Activity diagrams
• Interaction diagrams
• Use case diagrams

All the above show the dynamic sequence of flow in a system.

Architectural Modeling

Architectural model represents the overall

framework of the system.
It contains both structural and behavioral elements
of the system.
Architectural model can be defined as the blueprint
of the entire system. Package diagram comes under
architectural modeling.
The process of Object-Oriented Software development.

The major phases of software development using object–

oriented methodology are:
object-oriented analysis,
object-oriented design, and
object-oriented implementation.
Object–Oriented Analysis:

• In this stage, the problem is formulated, user requirements are

identified, and then a model is built based upon real–world
objects.
• The analysis produces models on how the desired system should
function and how it must be developed.
• The models do not include any implementation details so that it
can be understood and examined by any non–technical application
expert.
Object–Oriented Design:
System Design:
• In this stage, the complete architecture of the desired system is
designed.
• The system is conceived as a set of interacting subsystems that in
turn is composed of a hierarchy of interacting objects, grouped into
classes.
• System design is done according to both the system analysis model
and the proposed system architecture.
• Here, the emphasis is on the objects comprising the system rather
than the processes in the system.
Object Design:
• In this phase, a design model is developed based on both the models
developed in the system analysis phase and the architecture designed in
the system design phase.
• All the classes required are identified.
• The designer decides whether −
new classes are to be created from scratch,
any existing classes can be used in their original form, or
new classes should be inherited from the existing classes.
Object–Oriented Implementation:
• In this stage, the design model developed in the object design is
translated into code in an appropriate programming language or
software tool.
• The databases are created and the specific hardware requirements
are ascertained.
• Once the code is in shape, it is tested using specialized techniques to
identify and remove the errors in the code.
 Description of Design patterns:
• Design patterns represent the best practices used by experienced object-oriented
software developers.
• Design patterns are solutions to general problems that software developers faced
during software development. These solutions were obtained by trial and error by
numerous software developers over quite a substantial period of time.
Gang of Four (GOF):
• In 1994, four authors Erich Gamma, Richard Helm, Ralph Johnson and John
Vlissides published a book titled Design Patterns - Elements of Reusable Object-
Oriented Software which initiated the concept of Design Pattern in Software
development.
Principles of design patterns:
• Program to an interface not an implementation
• Favor object composition over inheritance
Types of Design Pattern:
1.Creational:
• These design patterns are all about class instantiation or object creation.
• These patterns can be further categorized into Class-creational patterns
and object-creational patterns.
• While class-creation patterns use inheritance effectively in the instantiation
process, object-creation patterns use delegation effectively to get the job
done.
Creational design patterns are the Factory Method, Abstract Factory, Builder,
Singleton, Object Pool, and Prototype.
2.Structural:
• These design patterns are about organizing different classes and objects to
form larger structures and provide new functionality.
• Structural design patterns are Adapter, Bridge, Composite, Decorator,
Facade, Flyweight, Private Class Data, and Proxy.
3.Behavioral:
• Behavioral patterns are about identifying common communication
patterns between objects and realizing these patterns.
• Behavioral patterns are Chain of responsibility, Command, Interpreter,
Iterator, Mediator, Memento, Null Object, Observer, State, Strategy,
Template method, Visitor
Factory Pattern:
• Factory pattern is one of the most used design patterns in Java. This type of
design pattern comes under creational pattern as this pattern provides one of
the best ways to create an object.
• In Factory pattern, we create object without exposing the creation logic to the
client and refer to newly created object using a common interface.
Implementation:
• We're going to create a Shape interface and concrete classes implementing
the Shape interface. A factory class ShapeFactory is defined as a next step.
• FactoryPatternDemo, our demo class will use ShapeFactory to get
a Shape object. It will pass information (CIRCLE / RECTANGLE / SQUARE)
to ShapeFactory to get the type of object it needs.
Abstract Factory Pattern:
• Abstract Factory patterns work around a super-factory which creates other
factories. This factory is also called as factory of factories. This type of
design pattern comes under creational pattern as this pattern provides one
of the best ways to create an object.
• In Abstract Factory pattern an interface is responsible for creating a factory
of related objects without explicitly specifying their classes. Each generated
factory can give the objects as per the Factory pattern.
Implementation:
• We are going to create a Shape interface and a concrete class
implementing it. We create an abstract factory class AbstractFactory as
next step. Factory class ShapeFactory is defined, which extends
AbstractFactory. A factory creator/generator class FactoryProducer is
created.
• AbstractFactoryPatternDemo, our demo class uses FactoryProducer to get a
AbstractFactory object. It will pass information (CIRCLE / RECTANGLE /
SQUARE for Shape) to AbstractFactory to get the type of object it needs.
Singleton Pattern:

• Singleton pattern is one of the simplest design patterns in Java.

This type of design pattern comes under creational pattern as
this pattern provides one of the best way to create an object.
• This pattern involves a single class which is responsible to
creates own object while making sure that only single object
get created.
• This class provides a way to access its only object which can be
accessed directly without need to instantiate the object of the
class.
 Implementation:
• We're going to create a SingleObject class. SingleObject class have its
constructor as private and have a static instance of itself.
• SingleObject class provides a static method to get its static instance to
outside world. SingletonPatternDemo, our demo class will
use SingleObject class to get a SingleObject object.
Builder Pattern:
• Builder pattern builds a complex object using simple objects and using a
step by step approach. This type of design pattern comes under creational
pattern as this pattern provides one of the best ways to create an object.
• A Builder class builds the final object step by step. This builder is
independent of other objects.
Implementation:
• We have considered a business case of fast-food restaurant where a typical
meal could be a burger and a cold drink. Burger could be either a Veg
Burger or Chicken Burger and will be packed by a wrapper. Cold drink
could be either a coke or pepsi and will be packed in a bottle.
• We are going to create an Item interface representing food items such as burgers and cold
drinks and concrete classes implementing the Item interface and a Packing interface
representing packaging of food items and concrete classes implementing
the Packing interface as burger would be packed in wrapper and cold drink would be
packed as bottle.
We then create a Meal class having ArrayList of Item and a MealBuilder to build different
types of Meal objects by combining Item. BuilderPatternDemo, our demo class will
use MealBuilder to build a Meal.
Prototype Pattern:

• Prototype pattern refers to creating duplicate object while keeping

performance in mind. This type of design pattern comes under creational
pattern as this pattern provides one of the best ways to create an object.
• This pattern involves implementing a prototype interface which tells to
create a clone of the current object. This pattern is used when creation of
object directly is costly. For example, an object is to be created after a
costly database operation. We can cache the object, returns its clone on
next request and update the database as and when needed thus reducing
database calls.
Implementation:
• We're going to create an abstract class Shape and concrete classes
extending the Shape class. A class ShapeCache is defined as a next step
which stores shape objects in a Hashtable and returns their clone when
requested.
• PrototypPatternDemo, our demo class will use ShapeCache class to get
a Shape object.
Adapter pattern:
• Adapter pattern works as a bridge between two incompatible interfaces.
This type of design pattern comes under structural pattern as this pattern
combines the capability of two independent interfaces.
• This pattern involves a single class which is responsible to join
functionalities of independent or incompatible interfaces. A real life
example could be a case of card reader which acts as an adapter between
memory card and a laptop. You plugin the memory card into card reader
and card reader into the laptop so that memory card can be read via
laptop.
• We are demonstrating use of Adapter pattern via following example in
which an audio player device can play mp3 files only and wants to use an
advanced audio player capable of playing vlc and mp4 files.
Implementation:
• We have a MediaPlayer interface and a concrete
class AudioPlayer implementing the MediaPlayer interface. AudioPlayer can
play mp3 format audio files by default.
• We are having another interface AdvancedMediaPlayer and concrete classes
implementing the AdvancedMediaPlayer interface. These classes can play vlc
and mp4 format files.
• We want to make AudioPlayer to play other formats as well. To attain this, we
have created an adapter class MediaAdapter which implements
the MediaPlayer interface and uses AdvancedMediaPlayer objects to play the
required format.
• AudioPlayer uses the adapter class MediaAdapter passing it the desired audio
type without knowing the actual class which can play the desired
format. AdapterPatternDemo, our demo class will use AudioPlayer class to
play various formats.
Bridge pattern:
• Bridge is used when we need to decouple an abstraction from its
implementation so that the two can vary independently. This type of
design pattern comes under structural pattern as this pattern decouples
implementation class and abstract class by providing a bridge structure
between them.
• This pattern involves an interface which acts as a bridge which makes the
functionality of concrete classes independent from interface implementer
classes. Both types of classes can be altered structurally without affecting
each other.
• We are demonstrating use of Bridge pattern via following example in
which a circle can be drawn in different colors using same abstract class
method but different bridge implementer classes.
Implementation:
• We have a DrawAPI interface which is acting as a bridge implementer and
concrete classes RedCircle, GreenCircle implementing
the DrawAPI interface. Shape is an abstract class and will use object
of DrawAPI. BridgePatternDemo, our demo class will use Shape class to
draw different colored circle.
Filter Pattern:
• Filter pattern or Criteria pattern is a design pattern that enables
developers to filter a set of objects using different criteria and chaining
them in a decoupled way through logical operations. This type of design
pattern comes under structural pattern as this pattern combines multiple
criteria to obtain single criteria.
Implementation:
• We're going to create a Person object, Criteria interface and concrete
classes implementing this interface to filter list
of Person objects. CriteriaPatternDemo, our demo class
uses Criteria objects to filter List of Person objects based on various criteria
and their combinations.
Composite Pattern:
• Composite pattern is used where we need to treat a group of objects
in similar way as a single object. Composite pattern composes objects
in term of a tree structure to represent part as well as whole
hierarchy. This type of design pattern comes under structural pattern
as this pattern creates a tree structure of group of objects.
• This pattern creates a class that contains group of its own objects.
This class provides ways to modify its group of same objects.
• We are demonstrating use of composite pattern via following
example in which we will show employees hierarchy of an
organization.
Implementation:
• We have a class Employee which acts as composite pattern actor
class. CompositePatternDemo, our demo class will use Employee class to
add department level hierarchy and print all employees.
Decorator Pattern:
• Decorator pattern allows a user to add new functionality to an
existing object without altering its structure. This type of design
pattern comes under structural pattern as this pattern acts as a
wrapper to existing class.
• This pattern creates a decorator class which wraps the original
class and provides additional functionality keeping class methods
signature intact.
• We are demonstrating the use of decorator pattern via following
example in which we will decorate a shape with some color
without alter shape class.
Implementation:
• We're going to create a Shape interface and concrete classes implementing
the Shape interface. We will then create an abstract decorator
class ShapeDecorator implementing the Shape interface and having Shape object
as its instance variable.
• RedShapeDecorator is concrete class implementing ShapeDecorator.
• DecoratorPatternDemo, our demo class will use RedShapeDecorator to
decorate Shape objects.
Facade Pattern:
• Facade pattern hides the complexities of the system and provides an
interface to the client using which the client can access the system. This
type of design pattern comes under structural pattern as this pattern adds
an interface to existing system to hide its complexities.
• This pattern involves a single class which provides simplified methods
required by client and delegates calls to methods of existing system classes.
Implementation:
• We are going to create a Shape interface and concrete classes
implementing the Shape interface. A facade class ShapeMaker is defined as
a next step.
ShapeMaker class uses the concrete classes to delegate user calls to these
classes. FacadePatternDemo, our demo class, will use ShapeMaker class to
show the results.
Flyweight Pattern:
• Flyweight pattern is primarily used to reduce the number of objects
created and to decrease memory footprint and increase performance.
• This type of design pattern comes under structural pattern as this pattern
provides ways to decrease object count thus improving the object
structure of application.
• Flyweight pattern tries to reuse already existing similar kind objects by
storing them and creates new object when no matching object is found.
• We will demonstrate this pattern by drawing 20 circles of different
locations but we will create only 5 objects. Only 5 colors are available so
color property is used to check already existing Circle objects.
Implementation:

• We are going to create a Shape interface and concrete

class Circle implementing the Shape interface. A factory
class ShapeFactory is defined as a next step.
• ShapeFactory has a HashMap of Circle having key as color of
the Circle object. Whenever a request comes to create a circle of particular
color to ShapeFactory, it checks the circle object in its HashMap, if object
of Circle found, that object is returned otherwise a new object is created,
stored in hashmap for future use, and returned to client.
• FlyWeightPatternDemo, our demo class, will use ShapeFactory to get
a Shape object. It will pass information (red / green / blue/ black / white)
to ShapeFactory to get the circle of desired color it needs.
Proxy Pattern:
• In proxy pattern, a class represents functionality of another class. This type
of design pattern comes under structural pattern.
• In proxy pattern, we create object having original object to interface its
functionality to outer world.
Implementation:
• We are going to create an Image interface and concrete classes
implementing the Image interface. ProxyImage is a a proxy class to reduce
memory footprint of RealImage object loading.
• ProxyPatternDemo, our demo class, will use ProxyImage to get
an Image object to load and display as it needs.
Chain of Responsibility Pattern:

• As the name suggests, the chain of responsibility pattern creates a chain

of receiver objects for a request. This pattern decouples sender and
receiver of a request based on type of request. This pattern comes under
behavioral patterns.
• In this pattern, normally each receiver contains reference to another
receiver. If one object cannot handle the request then it passes the same
to the next receiver and so on.
Implementation:
• We have created an abstract class AbstractLogger with a level of logging.
Then we have created three types of loggers extending the AbstractLogger.
Each logger checks the level of message to its level and print accordingly
otherwise does not print and pass the message to its next logger.
Command Pattern:
• Command pattern is a data driven design pattern and falls under
behavioral pattern category. A request is wrapped under an object as
command and passed to invoker object. Invoker object looks for the
appropriate object which can handle this command and passes the
command to the corresponding object which executes the command.
Implementation:
• We have created an interface Order which is acting as a command. We
have created a Stock class which acts as a request. We have concrete
command classes BuyStock and SellStock implementing Order interface
which will do actual command processing. A class Broker is created which
acts as an invoker object. It can take and place orders.
• Broker object uses command pattern to identify which object will
execute which command based on the type of
command. CommandPatternDemo, our demo class, will use Broker class
to demonstrate command pattern.
Interpreter Pattern:
• Interpreter pattern provides a way to evaluate language grammar or
expression. This type of pattern comes under behavioral pattern. This
pattern involves implementing an expression interface which tells to
interpret a particular context. This pattern is used in SQL parsing, symbol
processing engine etc.
Implementation:
• We are going to create an interface Expression and concrete classes
implementing the Expression interface. A class TerminalExpression is
defined which acts as a main interpreter of context in question. Other
classes OrExpression, AndExpression are used to create combinational
expressions.
• InterpreterPatternDemo, our demo class, will use Expression class to
create rules and demonstrate parsing of expressions.
Iterator Pattern:
• Iterator pattern is very commonly used design pattern in Java and .Net
programming environment. This pattern is used to get a way to access the
elements of a collection object in sequential manner without any need to
know its underlying representation.
• Iterator pattern falls under behavioral pattern category.
Implementation:
• We're going to create a Iterator interface which narrates navigation
method and a Container interface which retruns the iterator . Concrete
classes implementing the Container interface will be responsible to
implement Iterator interface and use it
• IteratorPatternDemo, our demo class will use NamesRepository, a concrete
class implementation to print a Names stored as a collection
in NamesRepository.
Mediator Pattern:
• Mediator pattern is used to reduce communication complexity between
multiple objects or classes.
• This pattern provides a mediator class which normally handles all the
communications between different classes and supports easy maintenance
of the code by loose coupling.
• Mediator pattern falls under behavioral pattern category.
Implementation:
• We are demonstrating mediator pattern by example of a chat room where
multiple users can send message to chat room and it is the responsibility of
chat room to show the messages to all users. We have created two
classes ChatRoom and User. User objects will use ChatRoom method to
share their messages.
• MediatorPatternDemo, our demo class, will use User objects to show
communication between them.
Memento Pattern:

• Memento pattern is used to restore state of an object to a previous state.

Memento pattern falls under behavioral pattern category.
Implementation:
• Memento pattern uses three actor classes. Memento contains state of an
object to be restored. Originator creates and stores states in Memento
objects and Caretaker object is responsible to restore object state from
Memento. We have created classes Memento, Originator and CareTaker.
• MementoPatternDemo, our demo class, will
use CareTaker and Originator objects to show restoration of object states.
Observer Pattern:
• Observer pattern is used when there is one-to-many relationship between
objects such as if one object is modified, its depenedent objects are to be
notified automatically.
• Observer pattern falls under behavioral pattern category.
Implementation:
• Observer pattern uses three actor classes. Subject, Observer and Client.
Subject is an object having methods to attach and detach observers to a
client object. We have created an abstract class Observer and a concrete
class Subject that is extending class Observer.
• ObserverPatternDemo, our demo class, will use Subject and concrete class
object to show observer pattern in action.
State Pattern:
• In State pattern a class behavior changes based on its state.
• This type of design pattern comes under behavior pattern.
• In State pattern, we create objects which represent various states and a
context object whose behavior varies as its state object changes.
Implementation:
• We are going to create a State interface defining an action and concrete
state classes implementing the State interface. Context is a class which
carries a State.
• StatePatternDemo, our demo class, will use Context and state objects to
demonstrate change in Context behavior based on type of state it is in.
Null Object Pattern:
• In Null Object pattern, a null object replaces check of NULL object instance.
• Instead of putting if check for a null value, Null Object reflects a do nothing
relationship.
• Such Null object can also be used to provide default behaviour in case data
is not available.
• In Null Object pattern, we create an abstract class specifying various
operations to be done, concrete classes extending this class and a null
object class providing do nothing implemention of this class and will be
used seemlessly where we need to check null value.
Implementation:
• We are going to create a AbstractCustomer abstract class defining
opearations. Here the name of the customer and concrete classes
extending the AbstractCustomer class. A factory class CustomerFactory is
created to return either RealCustomer or NullCustomer objects based on
the name of customer passed to it.
• NullPatternDemo,our demo class, will use CustomerFactory to
demonstrate the use of Null Object pattern.
Strategy Pattern:
• In Strategy pattern, a class behavior or its algorithm can be changed at run
time.
• This type of design pattern comes under behavior pattern.
• In Strategy pattern, we create objects which represent various strategies
and a context object whose behavior varies as per its strategy object.
• The strategy object changes the executing algorithm of the context object.
Implementation:
• We are going to create a Strategy interface defining an action and concrete
strategy classes implementing the Strategy interface. Context is a class
which uses a Strategy.
• StrategyPatternDemo, our demo class, will use Context and strategy
objects to demonstrate change in Context behaviour based on strategy it
deploys or uses.
Template Pattern:
• In Template pattern, an abstract class exposes defined way(s)/template(s)
to execute its methods.
• Its subclasses can override the method implementation as per need but
the invocation is to be in the same way as defined by an abstract class.
• This pattern comes under behavior pattern category.
Implementation:
• We are going to create a Game abstract class defining operations with a
template method set to be final so that it cannot be
overridden. Cricket and Football are concrete classes that
extend Game and override its methods.
• TemplatePatternDemo, our demo class, will use Game to demonstrate use
of template pattern.
Visitor Pattern:
• In Visitor pattern, we use a visitor class which changes the executing
algorithm of an element class.
• By this way, execution algorithm of element can vary as and when visitor
varies.
• This pattern comes under behavior pattern category.
• As per the pattern, element object has to accept the visitor object so that
visitor object handles the operation on the element object.
Implementation:
• We are going to create a ComputerPart interface defining accept
opearation.Keyboard, Mouse, Monitor and Computer are concrete classes
implementing ComputerPart interface. We will define another
interface ComputerPartVisitor which will define a visitor class
operations. Computer uses concrete visitor to do corresponding action.
• VisitorPatternDemo, our demo class, will use
use Computer and ComputerPartVisitor classes to demonstrate use of
visitor pattern.
Technological Description of Distributed Systems.
• A distributed system contains multiple nodes that are physically separate
but linked together using the network. All the nodes in this system
communicate with each other and handle processes in tandem.
• Each of these nodes contains a small part of the distributed operating
system software.
• A diagram to better explain the distributed system is -
Types of Distributed Systems:
Client/Server Systems:
• In client server systems, the client requests a resource and the server
provides that resource.
• A server may serve multiple clients at the same time while a client is in
contact with only one server.
• Both the client and server usually communicate via a computer network
and so they are a part of distributed systems.
Peer to Peer Systems:
• The peer to peer systems contains nodes that are equal participants in data
sharing.
• All the tasks are equally divided between all the nodes. The nodes interact
with each other as required as share resources.
• This is done with the help of a network.
 Advantages of Distributed
Systems:

Some advantages of Distributed Systems are as follows −

• All the nodes in the distributed system are connected to each other. So
nodes can easily share data with other nodes.
• More nodes can easily be added to the distributed system i.e. it can be
scaled as required.
• Failure of one node does not lead to the failure of the entire distributed
system. Other nodes can still communicate with each other.
• Resources like printers can be shared with multiple nodes rather than being
restricted to just one.
Disadvantages of Distributed Systems:

Some disadvantages of Distributed Systems are as follows −

• It is difficult to provide adequate security in distributed systems because
the nodes as well as the connections need to be secured.
• Some messages and data can be lost in the network while moving from
one node to another.
• The database connected to the distributed systems is quite complicated
and difficult to handle as compared to a single user system.
• Overloading may occur in the network if all the nodes of the distributed
system try to send data at once.