Class responsibilities and behavior in LLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Single Responsibility Principle

Which of the following best describes the Single Responsibility Principle (SRP) in class design?

A A class should have only one reason to change, meaning it should have only one responsibility.

B A class should handle multiple responsibilities to reduce the number of classes in the system.

C A class should inherit from multiple classes to gain various behaviors.

D A class should expose all its internal data to other classes for flexibility.

💡 Hint

Think about how many reasons a class should have to change.

The Single Responsibility Principle states that a class should have only one reason to change, meaning it should focus on a single responsibility or behavior.

❓ Architecture

intermediate

Class Behavior Distribution in a Library Management System

In a library management system, which class should be responsible for checking out a book to a user?

A The Book class, because it represents the book being checked out.

B The Library class, because it manages the collection of books.

C A separate CheckoutManager class, responsible for managing the checkout process.

D The User class, because it represents the person borrowing the book.

💡 Hint

Consider which class should handle the process involving multiple entities.

The CheckoutManager class is responsible for coordinating the checkout process, involving both the User and the Book, keeping responsibilities clear and separated.

❓ scaling

advanced

Scaling Class Responsibilities in a Messaging App

As a messaging app grows, which approach best helps to keep class responsibilities manageable and scalable?

A Avoid creating new classes and use global functions for all behaviors.

B Combine all message handling, user management, and notification logic into a single MessageService class.

C Let each class handle unrelated tasks to reduce the number of classes in the system.

D Divide responsibilities into specialized classes like MessageHandler, UserManager, and NotificationService.

💡 Hint

Think about how to keep classes focused and easy to maintain as the system grows.

Dividing responsibilities into specialized classes helps maintain clear boundaries, making the system easier to scale and maintain.

❓ tradeoff

advanced

Tradeoffs in Class Responsibility Granularity

What is a potential downside of making classes too fine-grained with very narrow responsibilities?

A It can lead to too many classes, making the system complex to navigate and maintain.

B It always improves performance by reducing class size.

C It reduces code reuse by forcing duplication in each class.

D It eliminates the need for interfaces or abstractions.

💡 Hint

Consider what happens when there are many small classes in a system.

While fine-grained classes improve focus, having too many can make the system harder to understand and maintain due to increased complexity.

❓ component

expert

Identifying Class Responsibilities in a Ride-Sharing System

In a ride-sharing system, which class should be responsible for calculating the fare of a ride?

A The Driver class, because the driver provides the service.

B The FareCalculator class, dedicated to computing fares based on ride details and pricing rules.

C The Ride class, because it represents the trip details and duration.

D The User class, because the user pays the fare.

💡 Hint

Think about separating calculation logic from data representation.

The FareCalculator class centralizes fare computation logic, keeping pricing rules separate from data classes like Ride or User.

Practice

1. Which of the following best describes the main responsibility of a class in low-level design?

easy

A. To store only data without any methods

B. To group related data and behaviors together

C. To execute the entire program logic

D. To act as a database table

Solution

1. Step 1: Understand class purpose

   A class is designed to bundle data (attributes) and behaviors (methods) that operate on that data.

2. Step 2: Evaluate options

   To group related data and behaviors together correctly states this bundling. Options B, C, and D misunderstand class roles.

3. Final Answer:

   To group related data and behaviors together -> Option B

4. Quick Check:

   Class responsibility = Group data and behavior [OK]

Hint: Classes combine data and methods logically [OK]

Common Mistakes:

• Thinking classes only hold data
• Confusing classes with entire program logic
• Assuming classes are database tables

2. Which of the following is the correct way to define a method inside a class in Python?

easy

A. def methodName():

B. function methodName():

C. method methodName(self):

D. def methodName(self):

Solution

1. Step 1: Recall Python method syntax

   In Python, methods inside classes must include 'self' as the first parameter to access instance data.

2. Step 2: Check options

   def methodName(self): uses 'def' and includes 'self', which is correct. Options B and C use incorrect keywords. def methodName(): misses 'self'.

3. Final Answer:

   def methodName(self): -> Option D

4. Quick Check:

   Python method syntax = def methodName(self): [OK]

Hint: Remember 'self' is first parameter in Python methods [OK]

Common Mistakes:

• Omitting 'self' parameter
• Using 'function' keyword instead of 'def'
• Incorrect method declaration keywords

3. Given the following class definition, what will be the output of print(car.get_speed()) after creating car = Car(50)?

class Car:
    def __init__(self, speed):
        self.speed = speed
    def get_speed(self):
        return self.speed

medium

A. 50

B. speed

C. None

D. Error

Solution

1. Step 1: Understand object creation

   Creating car = Car(50) calls __init__, setting self.speed = 50.

2. Step 2: Analyze get_speed method

   get_speed returns self.speed, which is 50.

3. Final Answer:

   50 -> Option A

4. Quick Check:

   car.get_speed() returns 50 [OK]

Hint: Constructor sets attributes, methods return them [OK]

Common Mistakes:

• Confusing method return with attribute name
• Expecting method to print instead of return
• Forgetting to pass argument to constructor

4. Identify the error in the following class definition:

class Person:
    def __init__(self, name):
        name = name
    def get_name(self):
        return self.name

medium

A. The constructor does not assign to self.name

B. get_name method is missing self parameter

C. Class name should be lowercase

D. Constructor should not have parameters

Solution

1. Step 1: Check constructor assignment

   The constructor assigns 'name = name' which only assigns local variable, not instance variable.

2. Step 2: Check get_name method

   get_name returns self.name, but self.name was never set, causing error.

3. Final Answer:

   The constructor does not assign to self.name -> Option A

4. Quick Check:

   Instance variables need 'self.' prefix [OK]

Hint: Always assign instance variables with self. prefix [OK]

Common Mistakes:

• Assigning to local variable instead of self attribute
• Ignoring self parameter in methods
• Misunderstanding naming conventions

5. You are designing a BankAccount class. Which of the following responsibilities should NOT be part of this class to keep it focused and maintainable?

hard

A. Providing methods to deposit and withdraw money

B. Storing account balance and updating it

C. Validating user identity during login

D. Generating account statements

Solution

1. Step 1: Identify core responsibilities of BankAccount

   BankAccount should manage balance and transactions (deposit, withdraw) and possibly generate statements.

2. Step 2: Analyze user identity validation

   User identity validation is a separate concern, better handled by an authentication class, not BankAccount.

3. Final Answer:

   Validating user identity during login -> Option C

4. Quick Check:

   Separate concerns keep classes focused [OK]

Hint: Keep authentication separate from account data [OK]

Common Mistakes:

• Mixing unrelated responsibilities in one class
• Overloading class with authentication logic
• Ignoring single responsibility principle