Quiz: Inheritance and Polymorphism

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

Section 1: Multiple Choice (1 point each)

1. What does the syntax class Dog(Animal): mean?

• A) Dog contains an instance of Animal (composition)
• B) Dog inherits from Animal (inheritance)
• C) Dog and Animal are the same class
• D) Animal inherits from Dog

2. What is method overriding?

• A) Defining a new method that doesn't exist in the parent class
• B) Defining a method in a subclass with the same name as one in the parent, replacing the parent's version
• C) Calling super() to run the parent's method
• D) Preventing a method from being changed by subclasses

3. What happens if a subclass defines __init__ but does NOT call super().__init__()?

• A) Python automatically calls the parent's __init__
• B) The parent's attributes are never initialized, likely causing AttributeError later
• C) A SyntaxError is raised
• D) The subclass cannot be instantiated

4. Which of the following BEST describes polymorphism?

• A) A class that inherits from multiple parents
• B) Different objects responding to the same method call in their own way
• C) Hiding implementation details behind a simple interface
• D) Using isinstance() to check an object's type before calling methods

5. What does the @abstractmethod decorator do?

• A) Makes a method private so subclasses cannot access it
• B) Makes a method static so it doesn't require self
• C) Requires subclasses to implement the method; prevents instantiation of the abstract class
• D) Automatically generates the method body

6. When should you use composition instead of inheritance?

• A) When the relationship is "has-a" (a Car has an Engine)
• B) When the relationship is "is-a" (a Dog is an Animal)
• C) When you want to save typing by inheriting methods
• D) Whenever you want to reuse code from another class

7. What is the Method Resolution Order (MRO)?

• A) The order in which methods are defined within a class
• B) The order in which Python searches classes in a hierarchy when looking up a method
• C) The order in which __init__ methods are called
• D) The alphabetical ordering of method names

8. What is the output of this code?

class Parent:
    def speak(self):
        return "Parent speaks"

class Child(Parent):
    def speak(self):
        return "Child speaks"

obj = Child()
print(obj.speak())

• A) Parent speaks
• B) Child speaks
• C) Parent speaks followed by Child speaks
• D) AttributeError

9. What does isinstance(obj, ParentClass) return when obj is an instance of a child class?

• A) True
• B) False
• C) It raises a TypeError
• D) It depends on the child class

10. Which of the following violates the Liskov Substitution Principle?

• A) A Dog subclass that overrides speak() to return "Woof" instead of the parent Animal's "...".
• B) A Penguin subclass of Bird that raises NotImplementedError from fly().
• C) A Square subclass of Shape that implements area() differently from Rectangle.
• D) A SortedList subclass of list that overrides append() to maintain sort order.

Section 2: Short Answer (2 points each)

11. Write a minimal class hierarchy: an Animal base class with a sound() method, and Dog and Cat subclasses that override sound(). Show that a single loop can call sound() on all three types.

class Animal:
    def sound(self) -> str:
        return "..."

class Dog(Animal):
    def sound(self) -> str:
        return "Woof"

class Cat(Animal):
    def sound(self) -> str:
        return "Meow"

animals = [Dog(), Cat(), Animal()]
for a in animals:
    print(a.sound())
# Woof
# Meow
# ...

12. Explain the difference between overriding a method and extending it with super(). Give a one-line example of each.

def describe(self):
    return f"Dog: {self.name}"  # Parent's describe() is not called

def describe(self):
    return super().describe() + f" (breed: {self.breed})"

13. Why can't you create an instance of an abstract base class? What error do you get if you try?

TypeError: Can't instantiate abstract class ClassName with abstract method method_name

14. A Stack data structure supports push(), pop(), and peek(). Should Stack inherit from Python's list? Why or why not?

class Stack:
    def __init__(self):
        self._items = []  # Composition: Stack HAS a list

    def push(self, item):
        self._items.append(item)

    def pop(self):
        return self._items.pop()

15. What is the MRO of this class? Predict, then verify with print(D.__mro__).

class A:
    pass

class B(A):
    pass

class C(A):
    pass

class D(B, C):
    pass

D -> B -> C -> A -> object

print(D.__mro__)
# (<class 'D'>, <class 'B'>, <class 'C'>, <class 'A'>, <class 'object'>)

Section 3: Code Analysis (3 points each)

16. What is the output of this code? Trace through the execution step by step.

class Base:
    def __init__(self, x):
        self.x = x
        print(f"Base.__init__: x={self.x}")

    def show(self):
        print(f"Base.show: x={self.x}")


class Middle(Base):
    def __init__(self, x, y):
        super().__init__(x)
        self.y = y
        print(f"Middle.__init__: y={self.y}")


class Top(Middle):
    def __init__(self, x, y, z):
        super().__init__(x, y)
        self.z = z
        print(f"Top.__init__: z={self.z}")

    def show(self):
        super().show()
        print(f"Top.show: y={self.y}, z={self.z}")


t = Top(1, 2, 3)
t.show()

Base.__init__: x=1
Middle.__init__: y=2
Top.__init__: z=3
Base.show: x=1
Top.show: y=2, z=3

17. This code has a design flaw. Identify it and explain how to fix it.

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self) -> float:
        ...

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius

    def area(self) -> float:
        return 3.14159 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

# Someone tries to use Rectangle:
r = Rectangle(5, 10)
print(r.area())

TypeError: Can't instantiate abstract class Rectangle with abstract method area

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def area(self) -> float:
        return self.width * self.height

18. Analyze this code. Is the inheritance relationship appropriate? Why or why not?

class List:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

    def get(self, index):
        return self.items[index]

    def size(self):
        return len(self.items)

class Queue(List):
    def enqueue(self, item):
        self.add(item)

    def dequeue(self):
        return self.items.pop(0)

class Queue:
    def __init__(self):
        self._items = []  # Composition

    def enqueue(self, item):
        self._items.append(item)

    def dequeue(self):
        if not self._items:
            raise IndexError("Queue is empty")
        return self._items.pop(0)

    def size(self):
        return len(self._items)

Section 4: Design Questions (3 points each)

19. You're designing a document processing system with PDFDocument, WordDocument, and SpreadsheetDocument. Each can be opened, saved, and exported_to_text. Design the class hierarchy using an abstract base class. Write the class signatures (with __init__ and method signatures, but you can use ... for method bodies).

from abc import ABC, abstractmethod

class Document(ABC):
    def __init__(self, filename: str):
        self.filename = filename
        self.content = ""

    @abstractmethod
    def open(self) -> None:
        ...

    @abstractmethod
    def save(self) -> None:
        ...

    @abstractmethod
    def export_to_text(self) -> str:
        ...

    def __str__(self) -> str:
        return f"{type(self).__name__}: {self.filename}"

class PDFDocument(Document):
    def open(self) -> None: ...
    def save(self) -> None: ...
    def export_to_text(self) -> str: ...

class WordDocument(Document):
    def open(self) -> None: ...
    def save(self) -> None: ...
    def export_to_text(self) -> str: ...

class SpreadsheetDocument(Document):
    def open(self) -> None: ...
    def save(self) -> None: ...
    def export_to_text(self) -> str: ...

20. Compare these two designs for a music player. Which is better and why?

Design A (Inheritance):

class MusicPlayer(Playlist, AudioDecoder, Equalizer, Visualizer):
    pass

Design B (Composition):

class MusicPlayer:
    def __init__(self):
        self.playlist = Playlist()
        self.decoder = AudioDecoder()
        self.equalizer = Equalizer()
        self.visualizer = Visualizer()