June 23, 2024

Object Oriented Analysis and Design 2024 Q&A

Object Oriented Programming
Share :

Object Oriented Analysis & Design Question and Answer

(Suggest Find the question by search page and keep refreshing the page for updated content)

Q.1) A state government passes a new resolution on levying of taxation wherein they have different methods of taxation for different sections of society They have divided the society into – below poverty, low income, mid-income and high income groups and based on that tax calculation is to be done They have given the task of software development for same to their IT team. Expectation is that the design should be flexible to take in new Income groups without changing the interfaces for end user of the software ie taxation department. Also removal of any income group should not affect interfaces exposed to the end user. Please suggest which design pattern would suit most and why? Also draw a class diagram for same to show the chosen design pattern implementation.

One design pattern that would suit this scenario is the Strategy Pattern. The Strategy Pattern allows you to define a family of algorithms, encapsulate each one, and make them interchangeable. This would allow for flexible tax calculation methods for different income groups without changing the interfaces for the end user.

Here’s how you can implement the Strategy Pattern for this scenario:

| TaxStrategy |
| calculateTax |
| | |
+——————+ +——————+ +——————+
| BelowPovertyTax | | LowIncomeTax | | MidIncomeTax |
+——————+ +——————+ +——————+
| calculateTax | | calculateTax | | calculateTax |
+——————+ +——————+ +——————+

In this class diagram:

  • TaxStrategy is the interface defining the method calculateTax.
  • BelowPovertyTax, LowIncomeTax, MidIncomeTax, and potentially more classes represent different tax calculation strategies for various income groups, all implementing the TaxStrategy interface.

Q.2) Suppose we have a Factory that can create objects of various classes. It has methods like:
public ProductA create ProductA()
public ProductB create ProductB()

One problem with this is that every time we want to enable the Factory to create objects of a new class, we have to add a new method Describe another way to write methods in a Factory, which removes the need to add a new method when the Factory shall be able to create objects of a new class. Explain the pros and cons of the two ways to write a Factory.

  1. Reflection: Instead of hardcoding methods for each product type, the Factory could use reflection to dynamically instantiate objects based on class names.
  2. Configuration: The Factory would be configured with a mapping of product identifiers (e.g., strings or enums) to their corresponding class names.

Here’s how the revised Factory might look:

public class ProductFactory {
private Map<String, Class<?>> productRegistry = new HashMap<>();

public void registerProduct(String productId, Class<?> productClass) {
productRegistry.put(productId, productClass);

public Product createProduct(String productId) throws InstantiationException, IllegalAccessException {
Class<?> productClass = productRegistry.get(productId);
if (productClass != null) {
return (Product) productClass.newInstance();
} else {
throw new IllegalArgumentException("Unknown product ID: " + productId);

Then, the configuration might look something like this:

public class Main {
public static void main(String[] args) {
ProductFactory factory = new ProductFactory();
factory.registerProduct("A", ProductA.class);
factory.registerProduct("B", ProductB.class);

// Usage
try {
Product productA = factory.createProduct("A");
Product productB = factory.createProduct("B");
} catch (InstantiationException | IllegalAccessException e) {


  1. Dynamic: With this approach, you don’t need to modify the Factory class every time you introduce a new product type. You can simply register the new product class with the Factory.
  2. Configurable: The configuration mechanism allows you to change product mappings without altering the code, which provides more flexibility.


  1. Runtime Errors: Since reflection involves working with class names as strings, there’s a risk of runtime errors if a class name is mistyped or if a class is missing.
  2. Performance Overhead: Reflection can have performance overhead compared to direct method calls, although in many cases, this overhead might be negligible.
  3. Limited Compile-time Checks: Using reflection for object instantiation means that errors related to incorrect class mappings might only be discovered at runtime. This can make it harder to catch errors during development.

Q.3) Assume you’re working for ABC Software Company Ltd as a Design Engineer, Your Company will receive as order to develop a rice trader web application for Bhagyalakshmi rice Company, which will involve in selling rice bags in bulk and delivers the ordered quantity to retail shops, Your project manager will assign you to Draw a Activity diagram and Sequence diagram.
State suitable assumptions and draw the above diagrams assigned by your project manager (Diagram should to drawn with pen on a paper and should uploaded a scan copy of answer paper)



  1. The rice trader web application will have features for both bulk buyers (retail shops) and the Bhagyalakshmi rice company.
  2. Users will be able to register, log in, browse rice products, place orders, make payments, and track deliveries.
  3. Payment processing will be handled externally through a payment gateway.
  4. The system will have admins who can manage products, orders, and user accounts.
  5. The application will track inventory to ensure orders can be fulfilled.

Activity Diagram:

Start with a rectangle representing the start point of the process. Then, use action nodes (rectangles with rounded corners) to represent actions or operations in the process. Use decision nodes (diamond shapes) to represent points where the flow can take different paths based on conditions. Finally, end with a rectangle representing the end of the process.

Here’s a textual representation of the activity diagram:

Browse Products
Place Order
Make Payment
Track Delivery

Sequence Diagram:

A sequence diagram shows the interactions between different objects or components in a system over time. In this case, it will depict the interactions between the user, the web application, and external systems like the payment gateway.

Identify the actors involved (e.g., User, Web Application, Payment Gateway). Then, show the sequence of messages exchanged between them.

Here’s a textual representation of the sequence diagram:

User -> Web Application: Login/Registration
Web Application -> User: Acknowledge Login/Registration
User -> Web Application: Browse Products
Web Application -> User: Display Product List
User -> Web Application: Select Product
Web Application -> User: Display Product Details
User -> Web Application: Place Order
Web Application -> Payment Gateway: Initiate Payment Process
Payment Gateway -> Web Application: Payment Confirmation
Web Application -> User: Order Confirmation
Web Application -> Delivery System: Initiate Delivery Process
Delivery System -> Web Application: Delivery Confirmation
Web Application -> User: Delivery Tracking Information


Q.4) Every organization has an organizational chart. An organization chart depicts how the employees of the organization are structured from the highest level to the lowest level
Assume that an educational institution is constituted with the following designation level conditions:
The institution is headed by the PRINCIPAL
There are various departments. Each department is headed by a HEAD (HOD)
There are FACULTY members working under the HEAD
There are NON TEACHING FACULTY working under the PRINCIPAL
(a)Which is the suitable GOF pattern to represent the above scenario?
(b)Draw the domain model for the pattern for the problem, Attributes can be include according to your choice


(a) The suitable Gang of Four (GOF) pattern to represent the above scenario is the Composite Pattern.

(b) Here’s the domain model for the Composite Pattern in the context of the educational institution scenario:

+ getName(): String
+ add(component: OrganizationComponent): void
+ remove(component: OrganizationComponent): void
+ getChild(index: int): OrganizationComponent
+ display(): void

Leaf (implements OrganizationComponent)
- name: String
+ Leaf(name: String)
+ getName(): String
+ display(): void

Composite (implements OrganizationComponent)
- name: String
- components: List<OrganizationComponent>
+ Composite(name: String)
+ getName(): String
+ add(component: OrganizationComponent): void
+ remove(component: OrganizationComponent): void
+ getChild(index: int): OrganizationComponent
+ display(): void

Principal (extends Leaf)
+ Principal(name: String)
+ display(): void

Head (extends Composite)
+ Head(name: String)
+ display(): void

Faculty (extends Leaf)
+ Faculty(name: String)
+ display(): void

NonTeachingStaff (extends Leaf)
+ NonTeachingStaff(name: String)
+ display(): void

In this domain model:

  • OrganizationComponent is the abstract base class/interface for both Leaf and Composite classes.
  • Leaf represents the individual elements in the hierarchy, such as Principal, Faculty, and NonTeachingStaff.
  • Composite represents the higher-level containers like Head which can contain other Leaf or Composite elements.
  • Principal, Head, Faculty, and NonTeachingStaff are concrete classes implementing Leaf interface.
  • Head and Principal are also concrete classes implementing Composite interface as they can have children (either Leaf or Composite).


Q.5) Azcart is an online sales platform which supports Web, Desktop and mobile clients for browsing and placing orders for liked items. The system uses the following services to finish the process. “SalesService’ connects to ‘InventoryService’ which looks at DB for availability of product. ‘Payment Services’ connects to payment gateway for payment of order and ‘ShippingService’ for delivery of product from store to customers residence The application supports web clients via a controller of the application that interacts with the preceding services for an order. A user interacts with the Ul to place an order, the request is mapped to the controller, which in turn interacts with the services to fulfill the request, and then informs the user about the fulfillment status. Application also supports mobile clients and desktop clients. 
The diagram above shows multiple interactions with the services. Answer the following by considering the above case.
a) Which design pattern is most appropriate for the solution that you have chosen to overcome the problem? Explain it with the Context, Problem, solution, basic implementation and list out at least one alternate pattern?



In the context of Azcart, the system involves multiple complex interactions between various services like SalesService, InventoryService, PaymentService, and ShippingService. These services need to be coordinated to fulfill an order placed by a user through different client interfaces such as web, desktop, and mobile.


The problem lies in managing the complexity and dependencies between these services. Directly coupling the clients with the individual services can lead to tight coupling and increased complexity, making it difficult to maintain and scale the system.


The Facade Pattern provides a unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystem easier to use. In the context of Azcart:

  • Facade: We can create a facade class called OrderFacade that acts as an intermediary between the clients (web, desktop, mobile) and the underlying services (SalesService, InventoryService, PaymentService, ShippingService). This facade class encapsulates the complexity of interacting with these services.
  • Basic Implementation:
public class OrderFacade {
private SalesService salesService;
private InventoryService inventoryService;
private PaymentService paymentService;
private ShippingService shippingService;

// Constructor to inject dependencies

public void placeOrder(Order order) {
if (inventoryService.checkAvailability(order.getProduct())) {
shippingService.shipProduct(order.getProduct(), order.getAddress());
} else {
// Handle out of stock scenario

Alternate Pattern:

An alternative pattern to consider is the Mediator Pattern.

  • Mediator Pattern: This pattern defines an object that encapsulates how a set of objects interact. Instead of each object directly communicating with each other, they communicate through the mediator. In the context of Azcart, the mediator can handle the interactions between the different services and clients, acting as a central coordinator.

The choice between Facade and Mediator patterns depends on the specific requirements and the nature of interactions between components in the system. The Facade Pattern is more suitable when there’s a need to simplify a complex subsystem by providing a unified interface, whereas the Mediator Pattern is more suitable when the interaction between components becomes too complex and needs to be centralized. Since Azcart involves coordinating interactions between multiple services for order fulfillment, the Facade Pattern seems more appropriate.

Q.6) XYZ company is a product based company and it has launched a product in the market, named Schedule Server. It is a kind of server in itself, and it is used to manage jobs. The jobs could be any kind of jobs like sending a list of emails, SMS, reading or writing files from a destination, or just simply transferring files from a source to the destination. The product is used by the developers to manage such kind of jobs and able to concentrate more towards their business goal. The server executes each job at their specified time and also manages all underline issues like concurrency issue and security by itself. As a developer, one just need to code only the relevant business requirements and a good amount of API calls is provided to schedule a job according to their needs.
Everything was going fine, until the clients started complaining about starting and stopping the process of the server. They said, although the server is working great, the initializing and the shutting down processes are very complex and they want an easy way to do that. The server has exposed a complex interface to the clients which looks a bit hectic to them. We need to provide an easy way to start and stop the server. A complex interface to the client is already considered as a fault in the design of the current system. But fortunately or unfortunately, we cannot start the designing and the coding from scratch. We need a way to resolve this problem and make the interface easy to access. Which design pattern is suitable for the above problem and explain why?


the problem statement revolves around simplifying the interface for clients to start and stop the Schedule Server. To achieve this, we can apply the Facade design pattern.

Facade Design Pattern:

The Facade pattern provides a unified interface to a set of interfaces in a subsystem. It defines a higher-level interface that makes the subsystem easier to use for clients. In this case, the Facade pattern can hide the complexities of initializing and shutting down the Schedule Server, providing a simpler interface for clients to interact with.

How Facade Pattern Addresses the Problem:

  1. Hide Complexity: Facade pattern encapsulates the complex initialization and shutdown processes of the server behind a simpler interface. Clients no longer need to worry about the intricate details of these processes.
  2. Provide Simplified Interface: By providing a single, easy-to-use interface for starting and stopping the server, the Facade pattern simplifies client interaction. This addresses the clients’ complaint about the complex interface of the server.
  3. Promote Loose Coupling: Clients interact with the server through the Facade, promoting loose coupling between the client code and the server implementation. This allows for easier maintenance and future changes.

Implementation Approach:

  1. Facade Class: Create a facade class named something like ScheduleServerFacade that provides methods like startServer() and stopServer().
  2. Encapsulate Complexity: Inside the facade class, encapsulate the complex initialization and shutdown processes of the Schedule Server.
  3. Simple Interface: Expose only the necessary functionality through the facade methods, abstracting away the underlying complexities.
  4. Client Interaction: Clients interact with the Schedule Server through the facade methods, which shields them from the intricate details of server management.

Example Code Skeleton:

class ScheduleServer:
def initialize(self):
# Complex initialization logic

def shutdown(self):
# Complex shutdown logic

# Additional methods for server functionality

class ScheduleServerFacade:
def __init__(self):
self.server = ScheduleServer()

def startServer(self):
# Additional steps if needed

def stopServer(self):
# Additional cleanup steps if needed

# Client code
if __name__ == "__main__":
facade = ScheduleServerFacade()
# Perform server operations


The ScheduleServerFacade class acts as a simplified interface for clients. It encapsulates the initialization and shutdown processes of the Schedule Server within its methods startServer() and stopServer(). Clients interact with the server solely through these facade methods, abstracting away the complexities of server management.

By employing the Facade pattern, we effectively address the clients’ complaints about the complex interface of the Schedule Server, providing them with an easy way to start and stop the server without needing to delve into its intricate workings.

For More Updates Join Our Channels :