Look, Read, Understand, Apply


OOAD - Object Oriented Analysis and Design


The software development process

System development is a process of developing a system. System development process goes through several stages, in each stage the system grows; change, transformation, refinement are the subprocesses going in each stage. The system development process consists of subprocesses, each subprocess performs its own tasks. It is possible to replace one subprocess with same kind of another subprocess. The subprocesses interact with each other; gets input from subprocess and provides out to another or work independently and provide output to another subprocess.

The Software development process is similar to other development processes and can be divided into smaller, interacting subprocesses. The software development process is a series of transformations:

  • Transformation 1: In the software development process, requirements from the users are collected, those collected requirements are translated into system requirements.
  • Transformation 2: The system requirements are transformed to system design.
  • Transformation 3: The system design is refined, detailed and transformed into an operational system.

High-Quality Software

High-quality software must be able to address users’ requirements and expectations, the software should not have defects or have minimal defects. High quality software can be developed by figuring out answers for the following questions:
  • When will be system ready for delivery?
  • Is software operational and addresses users’ needs?
  • Is software doing what is it supposed to do and is doing correctly?
  • Does it pass an evaluation process?

Software can be evaluated using four quality measures:

  • Correspondence: How well the developed software satisfies the users’ requirements?
  • Correctness: Is software consistence with the design specification?
  • Verification: Is the software build in right way?
  • Validation: Is the software build is right?

Object-oriented systems development

The object-oriented software development life cycle has three processes:
  • Object-oriented Analysis
  • Object-oriented Design
  • Object-oriented Implementation

Object-oriented software development approach helps to view problem are a collection of objects interacting with each other to accomplish specified tasks and activities. It is difficult to have a well-defined problem, users are uncertain about the needs. Object-oriented software development advocates incremental development process to develop high-quality software. In Incremental development process software is developed in increments; refining, improving increment by increment. Object-oriented system development includes following activities:

  • Object-oriented analysis – use case driven
  • Object-oriented design
  • Prototyping
  • Component-based development
  • Incremental Testing

Object-oriented Analysis – Use-Case Driven

In the object-oriented analysis phase, the system requirements, classes and their relationships are identified. The actors of users of the system are determined, how they use the system. The concept of use case (name given by Ivar Jacobson for scenario) to describe the interaction between user and computer system is used to understand requirements of the users.

Use-case modeling, a method for expressing high-level processes and analyzing interaction between user and system is used during Object-oriented Analysis phase. The use-case model shows the users’ view of the software system and users’ need. Use-cases are developed iteratively; classes and their relationships are identified as use-case model becomes clearly understood and developed.

Object-Oriented Design

In the object-oriented design, classes identified during the analysis phase are design. Additional classes their relationships, interfaces are also identified and designed. The analysis and design phases overlap with each other. The object-oriented development is highly incremental in nature; analysis, design, then more analysis, refine, design process will continuously go on during the life cycle of the software development.

Object model based on objects and their relationships are built first:

  • Design and refine classes
  • Design and refine attributes
  • Design and refine methods
  • Design and refine structures
  • Design and refine interfaces


Prototype is a model. In the object-oriented analysis and design prototypes of some of the components of the system are created to get better understanding and picture of the system components. The developed prototypes are shown to the user for their comments on the usability and usefulness of those components. Prototypes give chance to define the use cases. Prototype helps to test and refine the user interfaces; the usability of those interfaces can be also increased. More details are added to the prototype as the prototype becomes consistent with the users requirements; prototype with added details are tested, evaluated and then refined during the develop process until the application components work properly.

Implementation: Component-Based Development

It is not necessary to develop software from the scratch. Software can be developed by integrating in-house built and well-tested components available in the Internet or the market. Basic ideas in using component-based development are: application can be developed quickly and a large collection of interpretable software components can be made available to other developers. Software components are functional units of a program; these components can interact with another component;

Incremental Testing

In object-oriented development method, analysis and design is done iteratively; software is developed in incremental fashion. Each development component should be tested immediately. If testing is done late after full-blown software is developed and problems, issues were found then it will be difficult to address those issues and problems. Object-oriented analysis and design approach advocates incremental testing of the components.


Object-oriented system development makes reusable components. That is components developed, tested, evaluated for correctness, correspondence during the system development can be used in another software.