Interview Prepoop-design-patternsmediumAmazonGoogleMicrosoftFlipkartTCSInfosys

Inheritance - Types, Method Resolution Order & Diamond Problem

Choose your preparation mode3 modes available

Solution Trace

▶

Steps

setup

Define Base Class A

We define the base class A with a method 'method' that prints 'A'. This is the root of the diamond.

💡 Starting with the base class is essential to understand how derived classes inherit and override methods.

Line:

class A:
    def method(self):
        print('A')

💡 Base class methods form the foundation for inheritance and method resolution.

class A:  # STEP 1
    def method(self):  # STEP 1
        print('A')  # STEP 1

class B(A):  # STEP 2
    def method(self):  # STEP 2
        print('B')  # STEP 2

class C(A):  # STEP 3
    def method(self):  # STEP 3
        print('C')  # STEP 3

class D(B, C):  # STEP 4
    pass  # STEP 4

print(D.__mro__)  # STEP 5

d = D()  # STEP 6
 d.method()  # STEP 6-9

📊

Inheritance - Types, Method Resolution Order & Diamond Problem - Watch the Algorithm Execute, Step by Step

Watching the step-by-step construction and method lookup in the diamond inheritance pattern reveals the subtlety of MRO and why it matters to avoid ambiguity.

Step 1/10

·Active fill★Answer cell

Defines base class with a concrete method.

+method()

Practice

(1/5)

1. When a class implements an interface and also extends an abstract class, what is the sequence of abstraction enforcement and implementation that occurs during object instantiation?

easy

A. The abstract class constructor runs, but interface methods have no implementation to run.

B. Interface methods are implemented first, then the abstract class constructor runs.

C. The class must implement interface methods before the abstract class constructor runs.

D. The abstract class's constructor runs first, then interface methods are implemented by the class.

4. Given the following thread-safe observer pattern code snippet, what will be the output after the sequence of operations shown below?

import threading

class Observer:
    def __init__(self, name):
        self.name = name
    def update(self, event_type, message):
        print(f"{self.name} received {event_type}: {message}")

class Subject:
    def __init__(self):
        self.lock = threading.Lock()
        self.observers = {}

    def subscribe(self, observer, event_type):
        with self.lock:
            if event_type not in self.observers:
                self.observers[event_type] = set()
            self.observers[event_type].add(observer)

    def unsubscribe(self, observer, event_type):
        with self.lock:
            if event_type in self.observers and observer in self.observers[event_type]:
                self.observers[event_type].remove(observer)
                if not self.observers[event_type]:
                    del self.observers[event_type]

    def notify(self, event_type, message):
        with self.lock:
            observers_snapshot = list(self.observers.get(event_type, []))
        for observer in observers_snapshot:
            observer.update(event_type, message)

subject = Subject()
obs1 = Observer('Obs1')
obs2 = Observer('Obs2')
subject.subscribe(obs1, 'eventA')
subject.subscribe(obs2, 'eventB')
subject.notify('eventA', 'Hello A')
subject.notify('eventB', 'Hello B')
subject.unsubscribe(obs1, 'eventA')
subject.notify('eventA', 'Hello again A')

What is printed?

easy

A. Obs1 received eventA: Hello A Obs2 received eventB: Hello B Obs1 received eventA: Hello again A

B. Obs1 received eventA: Hello A Obs1 received eventA: Hello again A Obs2 received eventB: Hello B

C. Obs2 received eventB: Hello B Obs1 received eventA: Hello again A

D. Obs1 received eventA: Hello A Obs2 received eventB: Hello B

5. Identify the bug in the following Python code implementing deep copy for the Profile class:

import copy

class Profile:
    def __init__(self, name, scores):
        self.name = name
        self.scores = scores

    def __deepcopy__(self, memo):
        new_name = self.name  # Bug here
        new_scores = copy.deepcopy(self.scores, memo)
        return Profile(new_name, new_scores)

original = Profile('Alice', [10, 20])
copy_obj = copy.deepcopy(original)
copy_obj.scores.append(30)
print(original.scores)

medium

A. Line assigning new_name = self.name does not deepcopy the name string

B. Line assigning new_scores = copy.deepcopy(self.scores, memo) incorrectly copies scores

C. The __init__ method does not initialize scores properly

D. The return statement returns a new Profile instead of modifying self

Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard

Define Base Class A

Define Class B inheriting from A

Define Class C inheriting from A

Define Class D inheriting from B and C

Compute Method Resolution Order (MRO) for D

Invoke method() on instance of D

Method lookup: Check D for method

Method lookup: Found method in B

Execute B.method()

Summary: Diamond Problem Resolved by MRO

Key Takeaways

Practice

Solution

Step 1: Understand interface role

Step 2: Abstract class constructor behavior

Step 3: Implementation of interface methods

Final Answer:

Quick Check:

Solution

Step 1: Understand the role of Dice

Step 2: Consider Player class responsibilities

Step 3: Analyze Board class role

Step 4: Role of GameController

Final Answer:

Quick Check:

Solution

Step 1: Recall LSP postcondition rule

Step 2: Trace client call

Step 3: Analyze options

Final Answer:

Quick Check:

Solution

Step 1: Trace subscriptions and notifications

Step 2: Trace unsubscribe and final notification

Final Answer:

Quick Check:

Solution

Step 1: Examine __deepcopy__ method

Step 2: Understand impact

Final Answer:

Quick Check:

Ready to prove it?

Step 1: Examine deepcopy method