Quiz: OOP Design: Patterns and Principles

Test your understanding before moving on. Target: 70% or higher to proceed confidently.

Section 1: Multiple Choice (1 point each)

1. What does the Single Responsibility Principle state?

• A) A class should have only one method
• B) A class should have only one reason to change
• C) A function should take only one parameter
• D) A module should contain only one class

2. Which of the following describes the Open/Closed Principle?

• A) Classes should be open for modification and closed for extension
• B) Open-source code should have closed documentation
• C) Classes should be open for extension but closed for modification
• D) Methods should be open (public) or closed (private), never both

3. What does "tight coupling" mean?

• A) Classes are well-organized and follow SRP
• B) Classes depend heavily on each other's internal details
• C) Classes have high cohesion
• D) Classes use abstract base classes

4. A class has methods for sending emails, calculating taxes, and resizing images. This class has:

• A) High cohesion
• B) Low cohesion
• C) Loose coupling
• D) Strong encapsulation

5. In the Strategy pattern, what is the "context"?

• A) The abstract base class that defines the strategy interface
• B) The class that uses a strategy object to delegate behavior
• C) The concrete implementation of a specific algorithm
• D) The client code that chooses which strategy to use

6. When should you use the Observer pattern?

• A) When you need to create objects of different types based on input
• B) When you need to swap algorithms at runtime
• C) When multiple objects need to react to another object's state changes
• D) When you need to make immutable data objects

7. What does the @dataclass decorator auto-generate?

• A) Only __init__
• B) __init__, __repr__, and __eq__
• C) __init__, __repr__, __eq__, and __hash__
• D) All dunder methods

8. What is a "code smell"?

• A) A syntax error that prevents code from running
• B) A runtime exception caused by bad input
• C) A surface indicator of a deeper design problem, even though the code works
• D) Code that has poor performance

9. Which of the following is the best reason to choose plain functions over OOP?

• A) You want to use polymorphism
• B) You're writing a short data transformation script with no persistent state
• C) You need multiple instances that maintain their own state
• D) You're building a library that others will extend

10. In the Factory pattern, what is the main benefit of the register() method (as shown in Section 16.6)?

• A) It makes the factory faster
• B) It allows adding new types without modifying the factory's source code
• C) It validates that new types are correct
• D) It removes the need for abstract base classes

Section 2: Short Answer (2 points each)

11. Explain the difference between coupling and cohesion using a restaurant analogy. What would "tight coupling" and "low cohesion" look like in a restaurant?

12. Look at this code and identify which design pattern it implements. Name the three roles (using the pattern's terminology):

class PricingRule(ABC):
    @abstractmethod
    def calculate(self, base_price: float) -> float: ...

class RegularPricing(PricingRule):
    def calculate(self, base_price: float) -> float:
        return base_price

class HolidaySale(PricingRule):
    def calculate(self, base_price: float) -> float:
        return base_price * 0.8

class Product:
    def __init__(self, name, base_price, pricing: PricingRule):
        self.name = name
        self.base_price = base_price
        self.pricing = pricing

    def get_price(self):
        return self.pricing.calculate(self.base_price)

13. What's wrong with this dataclass definition? Fix it.

@dataclass
class Team:
    name: str
    members: list[str] = []
    founded: int = 2024

from dataclasses import dataclass, field

@dataclass
class Team:
    name: str
    members: list[str] = field(default_factory=list)
    founded: int = 2024

14. A student writes this code and says, "I'm using the Observer pattern!" Are they correct? Why or why not?

class Logger:
    def log(self, message):
        print(f"[LOG] {message}")

class App:
    def __init__(self):
        self.logger = Logger()

    def do_something(self):
        self.logger.log("Did something")

Section 3: Code Analysis (3 points each)

15. What will this code print? Trace through the execution:

from abc import ABC, abstractmethod

class Notifier(ABC):
    @abstractmethod
    def notify(self, message: str) -> None:
        pass

class EmailNotifier(Notifier):
    def notify(self, message: str) -> None:
        print(f"Email: {message}")

class SMSNotifier(Notifier):
    def notify(self, message: str) -> None:
        print(f"SMS: {message}")

class EventSystem:
    def __init__(self):
        self._subscribers: list[Notifier] = []

    def subscribe(self, notifier: Notifier):
        self._subscribers.append(notifier)

    def emit(self, message: str):
        for sub in self._subscribers:
            sub.notify(message)

events = EventSystem()
events.subscribe(EmailNotifier())
events.subscribe(SMSNotifier())
events.subscribe(EmailNotifier())
events.emit("Server is down!")

Email: Server is down!
SMS: Server is down!
Email: Server is down!

16. This code uses the Factory pattern. What happens when create("xml") is called? What happens when create("json") is called?

class SerializerFactory:
    _serializers = {
        "json": lambda data: str(data),
        "csv": lambda data: ",".join(str(v) for v in data),
    }

    @classmethod
    def create(cls, format_name):
        serializer = cls._serializers.get(format_name)
        if serializer is None:
            raise ValueError(f"Unknown format: {format_name}")
        return serializer

fn = SerializerFactory.create("json")
print(fn({"a": 1, "b": 2}))

{'a': 1, 'b': 2}

ValueError: Unknown format: xml

17. Examine this refactoring. What specific improvements were made? Name the principles or patterns applied.

Before:

class Report:
    def generate(self, data, output_type):
        result = ""
        for item in data:
            result += f"{item['name']}: {item['value']}\n"

        if output_type == "console":
            print(result)
        elif output_type == "file":
            with open("report.txt", "w") as f:
                f.write(result)
        elif output_type == "html":
            html = f"<pre>{result}</pre>"
            with open("report.html", "w") as f:
                f.write(html)

After:

class ReportFormatter:
    def format(self, data):
        return "".join(f"{item['name']}: {item['value']}\n" for item in data)

class ConsoleOutput:
    def write(self, content):
        print(content)

class FileOutput:
    def __init__(self, filename):
        self.filename = filename
    def write(self, content):
        with open(self.filename, "w") as f:
            f.write(content)

class Report:
    def __init__(self, formatter, output):
        self.formatter = formatter
        self.output = output
    def generate(self, data):
        content = self.formatter.format(data)
        self.output.write(content)

18. Given these two dataclasses, predict the output:

from dataclasses import dataclass, field

@dataclass(order=True)
class Priority:
    level: int
    label: str = field(compare=False)

tasks = [
    Priority(3, "Low"),
    Priority(1, "Critical"),
    Priority(2, "Medium"),
    Priority(1, "Also Critical"),
]

print(sorted(tasks))
print(Priority(1, "Critical") == Priority(1, "Also Critical"))

[Priority(level=1, label='Critical'), Priority(level=1, label='Also Critical'), Priority(level=2, label='Medium'), Priority(level=3, label='Low')]
True

Section 4: Design Judgment (3 points each)

19. A student proposes this design for a school management system. Evaluate it — what's good and what should change?

SchoolSystem (one class):
  - add_student()
  - remove_student()
  - add_teacher()
  - remove_teacher()
  - assign_grade()
  - calculate_gpa()
  - generate_report_card()
  - schedule_class()
  - book_room()
  - process_tuition_payment()
  - send_newsletter()
  - order_supplies()

20. You're building a game where enemies can attack in different ways: melee, ranged, and magic. As the game grows, you'll add new attack types. A teammate suggests using inheritance:

class MeleeEnemy(Enemy): ...
class RangedEnemy(Enemy): ...
class MagicEnemy(Enemy): ...

Another suggests using the Strategy pattern. Which approach is better for this specific scenario? Explain your reasoning, and describe a scenario where the other approach would be better.