Object Oriented Analysis & Design

Assignment#1

NAME: Aiman Jawad

Roll #: BCSF19M523

SUBMITTED TO: SIR JUNAID QURESHI

Task 01
Class Vehicle {
String name;
String color;
Int No._Of_Seats;
Int Engine_Number;
Public:
Void Set_Name(string name){
this name->name;
}
Void Set_Color(string color){
this color->color;
 }
Void Set_ No._Of_Seats (int No._Of_Seats){
this No._Of_Seats -> No._Of_Seats;
}
Void Set_ Engine_Number (int Engine_Number){
this Engine_Number -> Engine_Number;
}
string Get_Name() { return name->name;}
string Get_Color() { return this->color;}
int Get_ No._Of_Seats() { this No._Of_Seats -> No._Of_Seats; }
int Get_ Engine_Number () { this Engine_Number -> Engine_Number; }
};

Class Car: public Vehicle{

Public:

};
int main(){
Car car1, car2;
car1.name(“Corolla”); car1.color(“White”); car1. No._Of_Seats(5); car1.Engine_Number(12345);

car2.name(“Sports Car”); car2.color(“Red”); car2. No._Of_Seats(2); car2.Engine_Number(9245);

return 0;
}
(A) Inheritance
The capability of a class to derive properties and characteristics from another
class is called Inheritance. Inheritance is one of the most important features of Object-
Oriented Programming. For example, a child inherits the traits of his/her parents. 

(B) Polymorphism
Polymorphism in C++ means, the same entity (function or object) behaves
differently in different scenarios. Example include overloading of arithmetic operators
(+,-,/,*). A person at the same time can have different characteristic. Like a man at the
same time is a father, a husband, an employee
(C) Abstraction
Abstraction means displaying only essential information and hiding the details.
Data abstraction refers to providing only essential information about the data to the
outside world.  For example, when we are driving a car, we are only concerned about
driving the car like start/stop the car, accelerate/ break, etc.

(D) Association
Association defines a relationship between classes of objects that allows one
object instance to cause another to perform an action on its behalf. For example, a
customer class has a single association to an Account class, indicating that each
Account instance is owned by one Customer instance.

Task02
Rational Rose is an object-oriented Unified Modeling Language (UML) software
design tool intended for visual modeling and component construction of enterprise-level
software applications.
Use of Rational Rose Software:
Rose is a powerful tool for software engineering teaching, which can be used for
all the phases of developing a software, like project analysis, design, realization and
testing. Moreover, it also supports the Rational Unified Process (RUP), which is required
for large software developing projects.

Two popular features of Rational Rose are its ability to provide iterative
development and round-trip engineering. Rational Rose allows designers to take
advantage of iterative development. As the developer begins to understand how the
components interact and makes modifications in the design, Rational Rose can perform
what is called "round-trip engineering" by going back and updating the rest of the model
to ensure the code remains consistent.

Task03
The Process Models which support the Agile methodology are as follows:
Extreme Programming (xp)
XP is built upon values, principles, and practices, and its goal is to allow small to mid-
sized teams to produce high-quality software and adapt to evolving and changing
requirements.
Scrum
The Scrum model suggests that projects progress via a series of sprints. In keeping with
an agile methodology, sprints are timeboxed to no more than a month long, most
commonly two weeks.
Crystal
Crystal method is an agile software development approach that focuses primarily on
people and their interactions when working on a project rather than on processes and
tools.

Task04
Unified Process Model is an iterative, incremental, architecture-centric, and use-case
driven approach for developing software. This model consists of four phases, including:
Inception, in which you collect requirements from the customer and analyze the project's
feasibility, its cost, risks, and profits.

Inception – identify core use cases, and use to make architecture and design tradeoffs.
Estimate and schedule project from derived knowledge.
Elaboration – capture detailed user requirements. Make detailed design, decide on
build or buy.
Construction – components are bought or built, and integrated.
Transition – release a mature version that satisfies acceptance criteria.

Task05
Requirement Traceability Matrix (RTM) is a document that maps and traces user
requirement with test cases. It captures all requirements proposed by the client and
requirement traceability in a single document, delivered at the conclusion of the
Software development life cycle.
The main purpose of Requirement Traceability Matrix is to validate that all requirements
are checked via test cases such that no functionality is unchecked during Software
testing.
Example:
Module High Level Requirement Low Level Requirement Status of
testcase
1) Loan Personal Loan Personal loan with private Passed
employee
Personal loan with Govt. Passed
employee
Personal loan for jobless people Passed
Car Loan Personal loan with private Passed
employee
Personal loan with Govt. Passed
employee

Task06
Requirements Engineering Process consists of the following main activities: Requirement
elicitation. Requirement specification. Requirement verification/validation and Requirements
management.

Question #7
Extend 
Extend is a directed relationship that specifies how and when the behavior defined in usually
supplementary (optional) extending use case can be inserted into the behavior defined in
the extended use case.

Include
Include relationship is a relationship in which one use case (the base use case) includes the
functionality of another use case.

System use case

A system use case diagram will detail functional specifications, including dependencies,
necessary internal supporting features and optional internal features. When writing a use case,
the design scope should be considered to identify all elements that lie within and outside the
boundaries of the processes.