Here are concise answers to all the questions in your image.
### 1. Why is reuse important in software design?
* Reduces development time and cost.
* Improves software quality through tested components.
* Increases productivity.
* Simplifies maintenance and promotes consistency.
### 2. Define OOD (Object-Oriented Design).
**Object-Oriented Design (OOD)** is the process of designing a software system
using objects, classes, relationships, and principles such as inheritance,
encapsulation, polymorphism, and abstraction.
### 3. What is a test model?
A **test model** is a structured representation of software requirements or behavior
used to design, organize, and execute test cases systematically.
### 4. Define UML diagram.
A **UML (Unified Modeling Language) diagram** is a standardized graphical
representation used to visualize, specify, construct, and document software systems.
### 5. What is the "access layer" in software design?
The **access layer** manages communication between the application and data
sources (such as databases). It performs data retrieval, storage, update, and deletion
while hiding database details from business logic.
### 6. Differentiate between objects and classes.
| Class | Object |
| ----------------------------------------- | ----------------------- |
| Blueprint/template | Instance of a class |
| Defines properties and methods | Has actual values |
| Logical entity | Physical/runtime entity |
| No memory allocated until object creation | Memory is allocated |
### 7. Describe the testing process briefly.
1. Requirement analysis
2. Test planning
3. Test case design
4. Test environment setup
5. Test execution
6. Defect reporting
7. Retesting and regression testing
8. Test closure
### 8. Explain "Basic Structural Modeling" in UML.
Basic Structural Modeling represents the static structure of a system using:
* Classes
* Objects
* Interfaces
* Packages
* Relationships (association, aggregation, composition, inheritance)
### 9. How does "working with construction" relate to software development?
Construction is the implementation phase where:
* Code is written.
* Classes and modules are developed.
* Unit testing and debugging are performed.
* The software design is converted into a working system.
### 10. Explain the role of packages.
Packages:
* Group related classes.
* Improve modularity.
* Reduce naming conflicts.
* Simplify maintenance and reuse.
* Control visibility and dependencies.
### 11. Explain the key principles of object-oriented thinking.
* **Abstraction:** Shows only essential features.
* **Encapsulation:** Protects data by combining data and methods.
* **Inheritance:** Reuses existing code through parent-child relationships.
* **Polymorphism:** One interface, multiple implementations.
These principles improve modularity, maintainability, and code reuse.
### 12. Describe the requirements model.
A **requirements model** describes what the system should do by capturing:
* Functional requirements
* Non-functional requirements
* User interactions
* Business rules
It serves as the foundation for analysis and design.
### 13. Discuss the significance of class visibility.
Class visibility controls access to members:
* **Public (+):** Accessible everywhere.
* **Private (-):** Accessible only within the class.
* **Protected (#):** Accessible within the class and subclasses.
* **Package (~):** Accessible within the package.
Benefits:
* Enhances security
* Supports encapsulation
* Reduces coupling
### 14. What is an Object-Oriented Lifecycle Model?
It is a software development process where analysis, design, implementation, testing,
and maintenance are performed using object-oriented concepts throughout the
project.
### 15. Define system testing.
**System testing** tests the complete integrated software system to verify that it
meets specified requirements.
### 16. What is the purpose of UML Object Constraint Language (OCL)?
**OCL** is used to specify precise rules and constraints that cannot be represented
graphically in UML diagrams.
### 17. What's the purpose of inheritance?
Inheritance:
* Promotes code reuse.
* Reduces duplication.
* Supports hierarchical classification.
* Enables polymorphism.
* Simplifies maintenance.
### 18. Differentiate between objects and classes.
* **Class:** Blueprint defining attributes and methods.
* **Object:** Runtime instance of a class with actual values.
### 19. Briefly describe OOA and OOSA.
**OOA (Object-Oriented Analysis):**
* Identifies system requirements.
* Finds objects, classes, and relationships.
**OOSA (Object-Oriented Systems Analysis):**
* A broader analysis approach focusing on the complete object-oriented system
before design.
### 20. Explain generalization and specialization.
* **Generalization:** Combines common features into a superclass.
* **Specialization:** Creates subclasses with additional or specific features.
Example:
* Vehicle → Car, Bike
### 21. Describe the Conceptual Model of UML.
The UML conceptual model consists of:
* **Building Blocks:** Things, relationships, diagrams.
* **Rules:** Guidelines for combining elements.
* **Common Mechani[Link] Specifications, adornments, divisions, extensibility.
### 22. Describe the design model.
A **design model** translates analysis into implementation by defining:
* Classes
* Interfaces
* Components
* Database design
* Interactions among objects
### 23. Explain the significance of UML OCL in class design.
OCL:
* Defines invariants, preconditions, and postconditions.
* Removes ambiguity.
* Improves model accuracy.
* Supports validation and verification.
### 24. Describe the testing process briefly.
The software testing process includes:
1. Requirement analysis
2. Test planning
3. Test case development
4. Environment setup
5. Test execution
6. Defect reporting
7. Regression testing
8. Test closure
These answers are suitable for **short-answer (2–5 marks)** examination questions.