S.O.L.I.D. Questions

Георгий Кузнецов

Score: 🔥 40

Beginner

Took 6 minutes

Coding Principles

S.O.L.I.D.

100%

Questions Attempted

10 / 10

Correct Answers

Incorrect Answers

Points Earned

🔥 10

Question 1

Which of these techniques can help achieve the Open/Closed Principle?

Hardcoding values directly into classes.
Using abstract classes and interfaces.
Copying and pasting code to create new functionality.
Avoiding the use of design patterns.

Explanation:

Abstraction, achieved through abstract classes and interfaces, is key to the OCP. It allows defining contracts that can be implemented by concrete classes, enabling extension without modifying the core logic.

Question 2

In a layered application, which layer typically contains the high-level modules according to DIP?

Database Layer
Presentation Layer
Business Logic Layer
Data Access Layer

Explanation:

The Business Logic Layer usually contains the core logic and high-level modules that orchestrate lower-level functionalities, adhering to DIP by depending on abstractions.

Question 3

SOLID principles primarily aim to improve which aspect of software development?

Execution Speed
Memory Optimization
Code Maintainability
Algorithm Efficiency

Explanation:

SOLID principles focus on creating code that is easier to understand, modify, and extend over time, thereby enhancing maintainability.

Question 4

What is the core idea behind the Liskov Substitution Principle (LSP)?

Classes should have only one responsibility.
Code should be open for extension, but closed for modification.
Subtypes should be substitutable for their base types without altering the correctness of the program.
Interfaces should be small and focused on a single task.

Explanation:

The LSP emphasizes that if you have a program working with a base class, you should be able to replace that base class with any of its subtypes without causing errors or unexpected behavior. This ensures the reliability and predictability of your code when dealing with inheritance hierarchies.

Question 5

Consider a base class 'Bird' with a method 'fly()'. You create a subclass 'Penguin'. What would be the most LSP-compliant approach in this scenario?

Have 'Penguin' inherit 'fly()' and throw an exception, as penguins cannot fly.
Rethink the inheritance hierarchy. 'Bird' might not be the right superclass for 'Penguin' if flying is a core characteristic.
Have 'Penguin' inherit 'fly()' but leave it empty, as penguins don't need to fly.
Remove the 'fly()' method from the 'Bird' class entirely.

Explanation:

This classic example highlights the importance of LSP in design. Forcing 'Penguin' to inherit a method it cannot logically use breaks substitutability. Restructuring the inheritance (perhaps with a 'FlightlessBird' superclass) often leads to a more accurate and maintainable design.

Question 6

How can you identify potential violations of the Liskov Substitution Principle in your code?

By only using abstract classes and interfaces.
By ensuring all methods in subclasses are static.
By looking for instances where a subclass throws an exception not declared in the superclass or introduces behavior that breaks the superclass's contract.
By avoiding inheritance altogether and favoring composition.

Explanation:

Code reviews and careful analysis are key to identifying LSP violations. Look for places where subclasses deviate from the expected behavior of their superclasses, especially in terms of exceptions thrown and method preconditions and postconditions. These are strong indicators that the principle might be compromised.

Question 7

What is the primary purpose of the Open/Closed Principle?

To prevent modification of existing code
To ensure all methods are open for modification
To allow extending functionality without altering existing code
To enforce the use of abstract classes

Explanation:

The Open/Closed Principle advocates that software entities should be open for extension but closed for modification, minimizing the risk of introducing bugs during changes.

Question 8

Which of the following best describes the Dependency Inversion Principle (DIP)?

High-level modules should depend on low-level modules.
Both high-level and low-level modules should depend on abstractions.
Low-level modules should depend on high-level modules.
Abstractions should depend on concrete implementations.

Explanation:

DIP states that both high-level and low-level modules should depend on abstractions, not directly on each other. This reduces coupling and increases flexibility.

Question 9

How does the Interface Segregation Principle relate to the idea of 'programming to an interface, not an implementation'?

They are unrelated concepts in software design.
ISP helps achieve the flexibility of using different implementations by keeping interfaces minimal and focused on client needs.
ISP contradicts this idea by promoting the use of concrete classes.
ISP only applies to statically typed languages, while 'programming to an interface' is a dynamic language concept.

Explanation:

When interfaces are small and client-specific (thanks to ISP), it becomes easier to swap out different implementations of those interfaces without affecting the client code. This promotes the flexibility advocated by 'programming to an interface'.

Question 10

What is the core idea behind the Single Responsibility Principle (SRP)?

A class should have only one method.
A class should have a single, well-defined responsibility.
A class should be as small as possible.
A class should interact with as few other classes as possible.

Explanation:

SRP emphasizes that a class should have one specific job or purpose, making it more maintainable and less prone to errors when changes are required.