ESS Exercise 6

What does the Single-Responsibility Principle (SRP) state?

• Handle multiple tasks at once

• Be reusable in different projects

• Have only one reason to change

• Be open for modification

Which of the following violates SRP?

• A class that handles user authentication

• A class that manages database connections

• A class that performs unit tests

• A class that handles both user authentication and database management

What does the Open/Closed Principle (OCP) state?

• Be closed for extension but open for modification

• Be open for extension but closed for modification

• Have multiple reasons to change

• Handle concrete implementations directly

Which design pattern often supports the OCP?

• Singleton

• Factory

• Observer

• Strategy

What is an example of violating the Open/Closed Principle?

• Adding new if-else blocks to handle additional types

• Extending a class without changing the original

• Using interfaces for all dependencies

• Using a for-loop to iterate over a list of objects

What does the Liskov Substitution Principle (LSP) state?

• Subtypes should add additional functionality to the base class.

• Subtypes should reduce the behavior of the base class.

• Subtypes must completely override the base class.

• Subtypes must be substitutable for their base types.

What would violate the Liskov Substitution Principle?

• A subclass that changes the behavior expected by the base class

• A subclass that does not use inheritance

• A subclass that implements an abstract method

• A subclass that implements an abstract method

What does the Interface Segregation Principle (ISP) state?

• Interfaces should have many methods for flexibility

• Clients should not depend on interfaces where they do not use all methods

• A large interface is easier to maintain

• Interfaces should be tightly coupled with clients

How does the Interface Segregation Principle improve design?

• By using fewer interfaces to simplify the system

• By forcing clients to depend on large interfaces

• By allowing tight coupling between interfaces

• By splitting large interfaces into smaller, more specific ones

What does the Dependency Inversion Principle (DIP) state?

• Depend on concrete classes, not abstractions

• Depend on abstractions, not concretions

• Use global variables for dependency injection

• High-level modules should depend on low-level modules