CPSA Software Design Principles Questions and Answers

Question 1

A software architect is designing a system where a `ReportGenerator` class needs access to customer data. Instead of allowing `ReportGenerator` to directly instantiate a `CustomerRepository` class, the architect mandates that `ReportGenerator` must depend on an `ICustomerRepository` interface. The concrete implementation will be provided at runtime. Which SOLID principle is primarily being applied?

Accepted Answer

Dependency Inversion Principle

Answer

The Dependency Inversion Principle (DIP) states that high-level modules should not depend on low-level modules; both should depend on abstractions. [28, 32] In this scenario, `ReportGenerator` (high-level) is decoupled from the concrete `CustomerRepository` (low-level) by depending on the `ICustomerRepository` abstraction (interface). [34] This allows the underlying data access implementation to change without affecting the report generation logic. [14]

Question 2

A team is developing a `PaymentProcessor` class that initially only handles credit card payments. A new requirement emerges to also support payments via a third-party gateway like PayPal. To adhere to the Open/Closed Principle, what is the BEST course of action?

Accepted Answer

Refactor the `PaymentProcessor` to use a strategy pattern, where different payment methods are implemented as separate classes that conform to a common `IPaymentStrategy` interface.

Answer

The Open/Closed Principle states that software entities should be open for extension but closed for modification. [9, 18] Adding if-else statements or new methods to the existing class modifies it, violating the principle. [1] Refactoring to a strategy pattern allows for the addition of new payment methods (extensions) by creating new strategy classes without changing the core `PaymentProcessor` class, which is closed for modification. [7]

Question 3

You are reviewing a class called `UserManager` that performs the following tasks: authenticates user credentials against a database, sends a welcome email to new users, formats user data into a JSON string for an API response, and logs every login attempt to a file. This class most clearly violates which design principle?

Accepted Answer

Single Responsibility Principle

Answer

The Single Responsibility Principle (SRP) states that a class should have only one reason to change. [21] The `UserManager` class has multiple responsibilities: authentication, notification, data formatting, and logging. [30] A change in the email template, the database schema, the API format, or the logging mechanism would each require a change to this single class, indicating a clear violation of SRP. [2, 30]

Question 4

A system has a base class `Bird` with a method `fly()`. A new requirement calls for adding an `Ostrich` class. Since an ostrich is a bird, the new class inherits from `Bird`. However, ostriches cannot fly, so the developer overrides the `fly()` method to throw a `NotSupportedException`. Why is this a violation of the Liskov Substitution Principle (LSP)?

Accepted Answer

Because an `Ostrich` object cannot be used wherever a `Bird` object is expected without potentially breaking the program's correctness.

Answer

The Liskov Substitution Principle (LSP) states that objects of a superclass should be replaceable with objects of its subclasses without altering the correctness of the program. [5, 11] If a piece of code expects a `Bird` object and calls its `fly()` method, substituting it with an `Ostrich` object would cause an exception, breaking the application's behavior. [26] The subclass alters the expected contract of the superclass, which violates LSP. [35]

Question 5

An architect is designing a modular system. They notice that a change to the `User` module frequently necessitates changes in the `Order`, `Invoice`, and `Shipping` modules. This is a symptom of what undesirable characteristic?

Accepted Answer

High Coupling

Answer

Coupling refers to the degree of interdependence between software modules. [12] High (or tight) coupling means that modules are closely connected, and changes in one module are likely to ripple through and require changes in other modules. [8, 22] This makes the system harder to maintain and evolve. The goal is to have low coupling, where modules are as independent as possible. [25]

CPSA Exam Practice Test

CPSA Exam Practice Test

CPSA Software Design Principles Questions and Answers