Object Oriented Software Engineering (OOSE) - Comprehensive Notes

UNIT I

No. of Hours: 10
Chapter / Book Reference: TB3 [Chapter 6]; TB2 [Chapter 2]

Object Oriented Concepts

1. Objects and Classes:

o Object: An object is an instance of a class that contains data and

behavior. For example, a "Car" object has data like color, speed, and
methods like drive() or stop().

o Class: A blueprint for creating objects. It defines properties (attributes)

and behaviors (methods).

o Objects encapsulate state and behavior, enabling modular and

maintainable code.

2. Links and Association:

o Association: A relationship between two classes. For instance, a

"Teacher" teaches multiple "Students".

o Associations can be one-to-one, one-to-many, or many-to-many.

o Link: A specific instance of an association. For example, the link between

teacher A and student B.

3. Generalization and Specialization:

o Generalization is the process of extracting shared characteristics from

two or more classes and combining them into a generalized superclass.

o Specialization is the reverse; creating new subclasses from an existing

class by adding unique features.

o Example: Class "Animal" is generalized; classes "Dog" and "Cat"

specialize it.

4. Inheritance:

o A mechanism for one class to acquire properties and methods of another.

o Promotes code reuse and logical hierarchy.

 o Types: Single, Multiple (not supported in Java), Multilevel, Hierarchical,
Hybrid.

5. Grouping Concepts:

o Refers to organizing classes into packages or modules.

o Enhances readability and maintainability.

o Packages provide namespace management and access control.

6. Aggregation and Composition:

o Aggregation: A weak association (has-a relationship) where the child can

exist independently of the parent.

▪ Example: A University has Colleges. Colleges can exist separately.

o Composition: A strong association where the child cannot exist without

the parent.

▪ Example: A House has Rooms. If House is destroyed, Rooms are

too.

7. Abstract Classes:

o Cannot be instantiated.

o Serve as base classes with partial implementation.

o Subclasses must implement abstract methods.

8. Polymorphism:

o Compile-time (Static): Method overloading (same method name with

different parameters).

o Runtime (Dynamic): Method overriding (subclass redefines superclass

method).

o Enhances flexibility and reusability.

9. Metadata:

o Information about data such as type, format, and structure.

o Used for object interpretation, reflection, and documentation.

10. Constraints:

o Rules or restrictions applied to attributes, methods, or relationships.

o Examples: age > 18, salary != null.

 o Enforced during design, implementation, or runtime.

11. Reuse:

o Reuse of software artifacts (code, designs, test cases) to reduce

development effort and cost.

o Achieved through inheritance, libraries, frameworks.

Object Oriented Methodologies

1. Rational Unified Process (RUP):

o A structured software development process.

o Iterative and incremental.

o Phases: Inception, Elaboration, Construction, Transition.

o Emphasizes architecture-centric and use-case-driven development.

2. Comparison with Traditional Lifecycle Model:

o Waterfall Model: Linear, sequential, difficult to accommodate changes.

o OO Lifecycle: Iterative, flexible, supports prototyping and feedback.

UML (Unified Modeling Language)

• A standardized modeling language to visualize system design.

• Developed by Grady Booch, Ivar Jacobson, and James Rumbaugh.

• Used to specify, visualize, modify, and document OO systems.

4+1 View Architecture:

1. Logical View: Class diagrams, object diagrams.

2. Development View: Component diagrams, packages.

3. Process View: Activity diagrams, interaction.

4. Physical View: Deployment diagrams.

5. Scenarios (Use Cases): Demonstrate how the system works.

Architecture

1. System Development Models:

o Process of constructing software systems from requirement gathering to

maintenance.

2. Model Building:
 o Creating abstract representations of real-world systems.

3. Model Architecture:

o High-level structure showing system components and interactions.

4. Requirements Model:

o Describes functional and non-functional requirements using use cases.

5. Analysis Model:

o Defines "what" the system should do.

o Includes use case diagrams, domain models.

6. Design Model:

o Defines "how" the system will do it.

o Class diagrams, sequence diagrams.

7. Implementation Model:

o Mapping classes and components to code.

8. Test Model:

o Includes test plans, test cases, and testing strategy.

UNIT II

No. of Hours: 10
Chapter / Book Reference: TB1 [Chapter 3]; TB3 [Chapters 7]

Project Management and Inception Phase

1. Project Management:

o Involves planning, executing, and closing projects.

o Ensures goals are met on time and within budget.

o Roles: Project manager, stakeholders, developers.

2. Unified Process and Inception Phase:

o Inception is the initial phase of the Unified Process.

o Goals:

▪ Understand business case and feasibility.

 ▪ Identify risks, costs, and major use cases.

▪ Prepare initial architecture and project plan.

o Deliverables:

▪ Vision document, use case model, initial risk assessment.

3. Project Monitoring and Control:

o Tracking progress and performance.

o Includes time tracking, scope control, and quality management.

o Tools: Gantt charts, burn-down charts.

Analysis

1. Requirements Model:

o Captures user expectations and system behavior.

o Divided into functional (features) and non-functional (performance,

usability).

2. Analysis Model:

o Representation of system from a problem domain viewpoint.

o Uses use case diagrams, domain models.

3. Use Cases:

o Describes how users interact with the system.

o Contains actors, scenarios, and flows.

4. Domain Classes:

o Represents core concepts in the problem domain.

o Includes attributes and methods of the entity.

5. Detailed Requirements:

o Specifies all system features with precision.

o Includes user stories, acceptance criteria.

UML Diagrams

1. Use Case Diagram:

o Shows interactions between users and system.

 o Elements: actors, use cases, relationships.

2. Activity Diagram:

o Describes workflows and business processes.

o Shows sequential flow of control.

3. System Sequence Diagram:

o Interaction between actor and system.

o Includes messages, objects, and sequence.

4. Object Diagram:

o Shows snapshot of objects and their relationships.

o Used for understanding runtime state.

5. Domain Class Model Diagram:

o Shows classes, attributes, and associations.

o Focuses on real-world entities and relationships.

UNIT III

No. of Hours: 12
Chapter / Book Reference: TB1 [Chapter 8-10]; TB2 [Chapters 8, 12]

Construction

1. Design Model:

o High-level structure and relationships.

o Blueprint for implementation.

2. Block Design:

o Decomposes system into blocks/modules.

o Each block has defined responsibilities.

3. Working with Construction:

o Converts design into code.

o Involves testing, integration, debugging.

4. Use Case Realization:

 o Design realization of use cases through classes and methods.

o Ensures consistency between requirements and implementation.

Designing the Subsystem

1. Mapping Design to Code:

o Translates model elements into code.

o Ensures maintainability and scalability.

2. Data Access Layer Design:

o Handles interaction with the database.

o Ensures separation of concerns and encapsulation.

3. UI and System Interfaces:

o UI: Frontend design and user interaction.

o System Interfaces: APIs and services for system integration.

Reusable Design Patterns

1. Importance of Design Patterns:

o Reusable solutions to common design problems.

o Improve code quality and maintainability.

2. Basic Patterns:

o Singleton: Ensures a class has only one instance.

o Multiton: Manages multiple named instances.

o Iterator: Accesses elements of a collection sequentially.

o Adapter: Converts one interface into another.

o Observer: Notifies dependents about changes.

UML Diagrams

1. Communication Diagram:

o Shows interactions among objects using messages.

2. Class Diagram:

o Shows classes, relationships, attributes, and methods.

3. State Transition Diagram:

 o Represents states and transitions of an object.

4. Package Diagram:

o Depicts packages and their dependencies.

5. Component Diagram:

o Illustrates components and their interdependencies.

6. Deployment Diagram:

o Shows physical deployment of components.

UNIT IV

No. of Hours: 8
Chapter / Book Reference: TB2 [Chapter 13]; TB3 [Chapter 12]

Testing Techniques

1. Terminology:

o Testing: Process of evaluating software for correctness.

o Defect: An issue in the code.

o Verification vs Validation.

2. Types of Tests:

o Unit Testing, Integration Testing, System Testing, Acceptance Testing.

o Manual vs Automated testing.

3. Testing Strategies:

o Black Box Testing: Based on input/output.

o White Box Testing: Internal logic.

o Regression Testing, Load Testing.

Testing Process

1. Testing Process Overview:

o Planning, Test Design, Execution, Defect Reporting, Closure.

2. Test Case Generation:

o Identifies test conditions, inputs, and expected outcomes.

 3. Automating Tests:

o Tools like Selenium, JUnit.

o Improves efficiency and repeatability.

Project Issues

1. Managing Complexity:

o Divide-and-conquer, modularization, abstraction.

2. Scrum and Agile Techniques:

o Agile: Iterative development methodology.

o Scrum: Framework with roles (Scrum Master, Product Owner),

ceremonies (Daily Standup, Sprint Planning).

3. Case Studies:

o Real-world examples demonstrating application of OOSE principles.