Practice Problems for Dependency Inversion Principle

Dependency Inversion Principle (DIP)

Practice Problems

To master the Dependency Inversion Principle (DIP), it's important to engage in practical exercises and projects. Here are some coding exercises, sample projects, quizzes, and multiple-choice questions (MCQs) to help reinforce your understanding.

Code Refactoring Exercise

Given:

A code snippet that violates DIP by having the high-level module depend directly on the low-level module:

Java

class CreditCardPayment {
    public void process() {
        System.out.println("Processing credit card payment");
    }
}

class PaymentProcessor {
    private CreditCardPayment payment;

    public PaymentProcessor() {
        this.payment = new CreditCardPayment();
    }

    public void processPayment() {
        payment.process();
    }
}

JavaScript

class CreditCardPayment {
  process() {
    console.log('Processing credit card payment')
  }
}

class PaymentProcessor {
  constructor() {
    this.payment = new CreditCardPayment()
  }

  processPayment() {
    this.payment.process()
  }
}

Python

class CreditCardPayment:
    def process(self):
        print("Processing credit card payment")

class PaymentProcessor:
    def __init__(self):
        self.payment = CreditCardPayment()

    def process_payment(self):
        self.payment.process()

Challenge: Refactor the code to adhere to DIP.

Refactored:

Java

// Abstraction
interface PaymentMethod {
    void process();
}

// High-Level Module
class PaymentProcessor {
    private PaymentMethod payment;

    public PaymentProcessor(PaymentMethod payment) {
        this.payment = payment;
    }

    public void processPayment() {
        payment.process();
    }
}

// Low-Level Module
class CreditCardPayment implements PaymentMethod {
    @Override
    public void process() {
        System.out.println("Processing credit card payment");
    }
}

class PayPalPayment implements PaymentMethod {
    @Override
    public void process() {
        System.out.println("Processing PayPal payment");
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        PaymentMethod paymentMethod = new CreditCardPayment();
        PaymentProcessor processor = new PaymentProcessor(paymentMethod);
        processor.processPayment();

        paymentMethod = new PayPalPayment();
        processor = new PaymentProcessor(paymentMethod);
        processor.processPayment();
    }
}

JavaScript

// Abstraction
class PaymentMethod {
  process() {
    throw new Error('This method should be overridden')
  }
}

// High-Level Module
class PaymentProcessor {
  constructor(payment) {
    this.payment = payment
  }

  processPayment() {
    this.payment.process()
  }
}

// Low-Level Modules
class CreditCardPayment extends PaymentMethod {
  process() {
    console.log('Processing credit card payment')
  }
}

class PayPalPayment extends PaymentMethod {
  process() {
    console.log('Processing PayPal payment')
  }
}

// Usage
const paymentMethod = new CreditCardPayment()
let processor = new PaymentProcessor(paymentMethod)
processor.processPayment() // Outputs: Processing credit card payment

const payPalPayment = new PayPalPayment()
processor = new PaymentProcessor(payPalPayment)
processor.processPayment() // Outputs: Processing PayPal payment

Python

from abc import ABC, abstractmethod

# Abstraction
class PaymentMethod(ABC):
    @abstractmethod
    def process(self):
        pass

# High-Level Module
class PaymentProcessor:
    def __init__(self, payment):
        self.payment = payment

    def process_payment(self):
        self.payment.process()

# Low-Level Modules
class CreditCardPayment(PaymentMethod):
    def process(self):
        print("Processing credit card payment")

class PayPalPayment(PaymentMethod):
    def process(self):
        print("Processing PayPal payment")

# Usage
payment_method = CreditCardPayment()
processor = PaymentProcessor(payment_method)
processor.process_payment()  # Outputs: Processing credit card payment

payment_method = PayPalPayment()
processor = PaymentProcessor(payment_method)
processor.process_payment()  # Outputs: Processing PayPal payment

Design Challenge

Challenge: Design a class hierarchy for a notification system that adheres to DIP. The system should have a high-level module that depends on abstractions for sending notifications, and low-level modules for email, SMS, and push notifications.

Example:

Java

// Abstraction
interface NotificationService {
    void sendNotification(String message);
}

// High-Level Module
class NotificationManager {
    private NotificationService notificationService;

    public NotificationManager(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void notifyUser(String message) {
        notificationService.sendNotification(message);
    }
}

// Low-Level Modules
class EmailNotification implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Sending email: " + message);
    }
}

class SMSNotification implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Sending SMS: " + message);
    }
}

class PushNotification implements NotificationService {
    @Override
    public void sendNotification(String message) {
        System.out.println("Sending push notification: " + message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        NotificationService notificationService = new EmailNotification();
        NotificationManager manager = new NotificationManager(notificationService);
        manager.notifyUser("Your order has been shipped!");

        notificationService = new SMSNotification();
        manager = new NotificationManager(notificationService);
        manager.notifyUser("Your package is out for delivery!");
    }
}

JavaScript

// Abstraction
class NotificationService {
  sendNotification(message) {
    throw new Error('This method should be overridden')
  }
}

// High-Level Module
class NotificationManager {
  constructor(notificationService) {
    this.notificationService = notificationService
  }

  notifyUser(message) {
    this.notificationService.sendNotification(message)
  }
}

// Low-Level Modules
class EmailNotification extends NotificationService {
  sendNotification(message) {
    console.log('Sending email: ' + message)
  }
}

class SMSNotification extends NotificationService {
  sendNotification(message) {
    console.log('Sending SMS: ' + message)
  }
}

class PushNotification extends NotificationService {
  sendNotification(message) {
    console.log('Sending push notification: ' + message)
  }
}

// Usage
const notificationService = new EmailNotification()
let manager = new NotificationManager(notificationService)
manager.notifyUser('Your order has been shipped!') // Outputs: Sending email: Your order has been shipped!

const smsNotification = new SMSNotification()
manager = new NotificationManager(smsNotification)
manager.notifyUser('Your package is out for delivery!') // Outputs: Sending SMS: Your package is out for delivery!

Python

from abc import ABC, abstractmethod

# Abstraction
class NotificationService(ABC):
    @abstractmethod
    def send_notification(self, message):
        pass

# High-Level Module
class NotificationManager:
    def __init__(self, notification_service):
        self.notification_service = notification_service

    def notify_user(self, message):
        self.notification_service.send_notification(message)

# Low-Level Modules
class EmailNotification(NotificationService):
    def send_notification(self, message):
        print("Sending email:", message)

class SMSNotification(NotificationService):
    def send_notification(self, message):
        print("Sending SMS:", message)

class PushNotification(NotificationService):
    def send_notification(self, message):
        print("Sending push notification:", message)

# Usage
notification_service = EmailNotification()
manager = NotificationManager(notification_service)
manager.notify_user("Your order has been shipped!")  # Outputs: Sending email: Your order has been shipped!

notification_service = SMSNotification()
manager = NotificationManager(notification_service)
manager.notify_user("Your package is out for delivery!")  # Outputs: Sending SMS: Your package is out for delivery!

Coding Exercises

• Exercise 1: Implement a Logging System:
  • Description: Create an abstraction for a logging service. Implement this abstraction in different classes for file logging, database logging, and console logging. Ensure that the high-level module depends on the abstraction.
  • Example:

Java

// Abstraction
interface Logger {
    void log(String message);
}

// High-Level Module
class LogManager {
    private Logger logger;

    public LogManager(Logger logger) {
        this.logger = logger;
    }

    public void logMessage(String message) {
        logger.log(message);
    }
}

// Low-Level Modules
class FileLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to file: " + message);
    }
}

class DatabaseLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to database: " + message);
    }
}

class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Logging to console: " + message);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Logger logger = new FileLogger();
        LogManager logManager = new LogManager(logger);
        logManager.logMessage("This is a file log message");

        logger = new DatabaseLogger();
        logManager = new LogManager(logger);
        logManager.logMessage("This is a database log message");

        logger = new ConsoleLogger();
        logManager = new LogManager(logger);
        logManager.logMessage("This is a console log message");
    }
}

JavaScript

// Abstraction
class Logger {
  log(message) {
    throw new Error('This method should be overridden')
  }
}

// High-Level Module
class LogManager {
  constructor(logger) {
    this.logger = logger
  }

  logMessage(message) {
    this.logger.log(message)
  }
}

// Low-Level Modules
class FileLogger extends Logger {
  log(message) {
    console.log('Logging to file: ' + message)
  }
}

class DatabaseLogger extends Logger {
  log(message) {
    console.log('Logging to database: ' + message)
  }
}

class ConsoleLogger extends Logger {
  log(message) {
    console.log('Logging to console: ' + message)
  }
}

// Usage
let logger = new FileLogger()
let logManager = new LogManager(logger)
logManager.logMessage('This is a file log message') // Outputs: Logging to file: This is a file log message

logger = new DatabaseLogger()
logManager = new LogManager(logger)
logManager.logMessage('This is a database log message') // Outputs: Logging to database: This is a database log message

logger = new ConsoleLogger()
logManager = new LogManager(logger)
logManager.logMessage('This is a console log message') // Outputs: Logging to console: This is a console log message

Python

from abc import ABC, abstractmethod

# Abstraction
class Logger(ABC):
    @abstractmethod
    def log(self, message):
        pass

# High-Level Module
class LogManager:
    def __init__(self, logger):
        self.logger = logger

    def log_message(self, message):
        self.logger.log(message)

# Low-Level Modules
class FileLogger(Logger):
    def log(self, message):
        print("Logging to file:", message)

class DatabaseLogger(Logger):
    def log(self, message):
        print("Logging to database:", message)

class ConsoleLogger(Logger):
    def log(self, message):
        print("Logging to console:", message)

# Usage
logger = FileLogger()
log_manager = LogManager(logger)
log_manager.log_message("This is a file log message")  # Outputs: Logging to file: This is a file log message

logger = DatabaseLogger()
log_manager = LogManager(logger)
log_manager.log_message("This is a database log message")  # Outputs: Logging to database: This is a database log message

logger = ConsoleLogger()
log_manager = LogManager(logger)
log_manager.log_message("This is a console log message")  # Outputs: Logging to console: This is a console log message

Sample Projects

• Project 1: Inventory Management System:
  • Description: Design an inventory management system with abstractions for product management, inventory tracking, and order processing. Implement these abstractions in different classes for managing products, tracking inventory levels, and processing orders. Ensure that the high-level module depends on the abstractions.
  • Example:

Java

// Abstractions
interface ProductManagement {
    void addProduct(String product);
    void removeProduct(String product);
}

interface InventoryTracking {
    void updateInventory(String product, int quantity);
    int checkInventory(String product);
}

interface OrderProcessing {
    void processOrder(String product, int quantity);
}

// High-Level Module
class InventoryManager {
    private ProductManagement productManagement;
    private InventoryTracking inventoryTracking;
    private OrderProcessing orderProcessing;

    public InventoryManager(ProductManagement productManagement, InventoryTracking inventoryTracking, OrderProcessing orderProcessing) {
        this.productManagement = productManagement;
        this.inventoryTracking = inventoryTracking;
        this.orderProcessing = orderProcessing;
    }

    public void manageInventory(String product, int quantity) {
        productManagement.addProduct(product);
        inventoryTracking.updateInventory(product, quantity);
        orderProcessing.processOrder(product, quantity);
    }
}

// Low-Level Modules
class SimpleProductManagement implements ProductManagement {
    @Override
    public void addProduct(String product) {
        System.out.println("Adding product: " + product);
    }

    @Override
    public void removeProduct(String product) {
        System.out.println("Removing product: " + product);
    }
}

class SimpleInventoryTracking implements InventoryTracking {
    @Override
    public void updateInventory(String product, int quantity) {
        System.out.println("Updating inventory for product: " + product + ", quantity: " + quantity);
    }

    @Override
    public int checkInventory(String product) {
        System.out.println("Checking inventory for product: " + product);
        return 100; // Sample return value
    }
}

class SimpleOrderProcessing implements OrderProcessing {
    @Override
    public void processOrder(String product, int quantity) {
        System.out.println("Processing order for product: " + product + ", quantity: " + quantity);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        ProductManagement productManagement = new SimpleProductManagement();
        InventoryTracking inventoryTracking = new SimpleInventoryTracking();
        OrderProcessing orderProcessing = new SimpleOrderProcessing();

        InventoryManager manager = new InventoryManager(productManagement, inventoryTracking, orderProcessing);
        manager.manageInventory("Product1", 10);
    }
}

JavaScript

// Abstractions
class ProductManagement {
  addProduct(product) {
    throw new Error('This method should be overridden')
  }

  removeProduct(product) {
    throw new Error('This method should be overridden')
  }
}

class InventoryTracking {
  updateInventory(product, quantity) {
    throw new Error('This method should be overridden')
  }

  checkInventory(product) {
    throw new Error('This method should be overridden')
  }
}

class OrderProcessing {
  processOrder(product, quantity) {
    throw new Error('This method should be overridden')
  }
}

// High-Level Module
class InventoryManager {
  constructor(productManagement, inventoryTracking, orderProcessing) {
    this.productManagement = productManagement
    this.inventoryTracking = inventoryTracking
    this.orderProcessing = orderProcessing
  }

  manageInventory(product, quantity) {
    this.productManagement.addProduct(product)
    this.inventoryTracking.updateInventory(product, quantity)
    this.orderProcessing.processOrder(product, quantity)
  }
}

// Low-Level Modules
class SimpleProductManagement extends ProductManagement {
  addProduct(product) {
    console.log('Adding product: ' + product)
  }

  removeProduct(product) {
    console.log('Removing product: ' + product)
  }
}

class SimpleInventoryTracking extends InventoryTracking {
  updateInventory(product, quantity) {
    console.log(
      'Updating inventory for product: ' + product + ', quantity: ' + quantity,
    )
  }

  checkInventory(product) {
    console.log('Checking inventory for product: ' + product)
    return 100 // Sample return value
  }
}

class SimpleOrderProcessing extends OrderProcessing {
  processOrder(product, quantity) {
    console.log(
      'Processing order for product: ' + product + ', quantity: ' + quantity,
    )
  }
}

// Usage
const productManagement = new SimpleProductManagement()
const inventoryTracking = new SimpleInventoryTracking()
const orderProcessing = new SimpleOrderProcessing()

const manager = new InventoryManager(
  productManagement,
  inventoryTracking,
  orderProcessing,
)
manager.manageInventory('Product1', 10) // Outputs: Adding product: Product1, Updating inventory for product: Product1, quantity: 10, Processing order for product: Product1, quantity: 10

Python

from abc import ABC, abstractmethod

# Abstractions
class ProductManagement(ABC):
    @abstractmethod
    def add_product(self, product):
        pass

    @abstractmethod
    def remove_product(self, product):
        pass

class InventoryTracking(ABC):
    @abstractmethod
    def update_inventory(self, product, quantity):
        pass

    @abstractmethod
    def check_inventory(self, product):
        pass

class OrderProcessing(ABC):
    @abstractmethod
    def process_order(self, product, quantity):
        pass

# High-Level Module
class InventoryManager:
    def __init__(self, product_management, inventory_tracking, order_processing):
        self.product_management = product_management
        self.inventory_tracking = inventory_tracking
        self.order_processing = order_processing

    def manage_inventory(self, product, quantity):
        self.product_management.add_product(product)
        self.inventory_tracking.update_inventory(product, quantity)
        self.order_processing.process_order(product, quantity)

# Low-Level Modules
class SimpleProductManagement(ProductManagement):
    def add_product(self, product):
        print("Adding product:", product)

    def remove_product(self, product):
        print("Removing product:", product)

class SimpleInventoryTracking(InventoryTracking):
    def update_inventory(self, product, quantity):
        print("Updating inventory for product:", product, ", quantity:", quantity)

    def check_inventory(self, product):
        print("Checking inventory for product:", product)
        return 100  # Sample return value

class SimpleOrderProcessing(OrderProcessing):
    def process_order(self, product, quantity):
        print("Processing order for product:", product, ", quantity:", quantity)

# Usage
product_management = SimpleProductManagement()
inventory_tracking = SimpleInventoryTracking()
order_processing = SimpleOrderProcessing()

manager = InventoryManager(product_management, inventory_tracking, order_processing)
manager.manage_inventory("Product1", 10)  # Outputs: Adding product: Product1, Updating inventory for product: Product1, quantity: 10, Processing order for product: Product1, quantity: 10

Quizzes

• Quiz 1: Identifying DIP Violations:
  • Question: Given the following code, identify the DIP violation and suggest a way to fix it.

Java

class FileStorage {
    public void save(String data) {
        System.out.println("Saving data to file");
    }
}

class DataManager {
    private FileStorage storage;

    public DataManager() {
        this.storage = new FileStorage();
    }

    public void saveData(String data) {
        storage.save(data);
    }
}

JavaScript

class FileStorage {
  save(data) {
    console.log('Saving data to file')
  }
}

class DataManager {
  constructor() {
    this.storage = new FileStorage()
  }

  saveData(data) {
    this.storage.save(data)
  }
}

Python

class FileStorage:
    def save(self, data):
        print("Saving data to file")

class DataManager:
    def __init__(self):
        self.storage = FileStorage()

    def save_data(self, data):
        self.storage.save(data)

• Answer:

Java

// Abstraction
interface Storage {
    void save(String data);
}

// Low-Level Module
class FileStorage implements Storage {
    @Override
    public void save(String data) {
        System.out.println("Saving data to file");
    }
}

// High-Level Module
class DataManager {
    private Storage storage;

    public DataManager(Storage storage) {
        this.storage = storage;
    }

    public void saveData(String data) {
        storage.save(data);
    }
}

// Usage
public class Main {
    public static void main(String[] args) {
        Storage storage = new FileStorage();
        DataManager dataManager = new DataManager(storage);
        dataManager.saveData("Sample data");
    }
}

JavaScript

// Abstraction
class Storage {
  save(data) {
    throw new Error('This method should be overridden')
  }
}

// Low-Level Module
class FileStorage extends Storage {
  save(data) {
    console.log('Saving data to file')
  }
}

// High-Level Module
class DataManager {
  constructor(storage) {
    this.storage = storage
  }

  saveData(data) {
    this.storage.save(data)
  }
}

// Usage
const storage = new FileStorage()
const dataManager = new DataManager(storage)
dataManager.saveData('Sample data') // Outputs: Saving data to file

Python

from abc import ABC, abstractmethod

# Abstraction
class Storage(ABC):
    @abstractmethod
    def save(self, data):
        pass

# Low-Level Module
class FileStorage(Storage):
    def save(self, data):
        print("Saving data to file")

# High-Level Module
class DataManager:
    def __init__(self, storage):
        self.storage = storage

    def save_data(self, data):
        self.storage.save(data)

# Usage
storage = FileStorage()
data_manager = DataManager(storage)
data_manager.save_data("Sample data")  # Outputs: Saving data to file

• Quiz 2: DIP and Abstractions:
  • Question: How does depending on abstractions rather than concrete implementations support the Dependency Inversion Principle (DIP)? Provide examples.
  • Answer:
    • Explanation: Depending on abstractions ensures that high-level modules are not tied to specific implementations. This decoupling allows for easier replacement or extension of low-level modules without affecting the high-level modules. For example, a PaymentProcessor class depending on a PaymentMethod interface can support multiple payment methods like CreditCardPayment and PayPalPayment without needing changes to the PaymentProcessor class.

Multiple-Choice Questions (MCQs)

• MCQ 1: What does the Dependency Inversion Principle state?

  • A) High-level modules should not depend on low-level modules. Both should depend on abstractions.
  • B) Classes should inherit from a single base class.
  • C) Methods should only be implemented once.
  • D) Classes should be open for extension but closed for modification.

  Answer: A) High-level modules should not depend on low-level modules. Both should depend on abstractions.

• MCQ 2: Which of the following is a violation of DIP?

  • A) A class that depends on an interface.
  • B) A class that directly depends on a concrete implementation.
  • C) A class that uses dependency injection.
  • D) A class that implements multiple interfaces.

  Answer: B) A class that directly depends on a concrete implementation.

• MCQ 3: How can you implement DIP in a large system?

  • A) By creating a single interface with all methods.
  • B) By using dependency injection frameworks to manage dependencies.
  • C) By avoiding the use of interfaces.
  • D) By directly creating dependencies within high-level modules.

  Answer: B) By using dependency injection frameworks to manage dependencies.

By working through these extensive practice problems, quizzes, and MCQs, you'll gain hands-on experience with the Dependency Inversion Principle, helping you to apply it effectively in your projects. These exercises will deepen your understanding and improve your ability to create maintainable, scalable, and flexible software systems.