Program to interface not implementation in LLD - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does 'Program to interface, not implementation' mean in system design?

It means writing code that depends on abstract interfaces rather than concrete classes. This allows flexibility to change implementations without affecting the rest of the system.

intermediate

Why is programming to an interface beneficial for scalability?

Because it allows swapping or adding new implementations without changing the code that uses the interface, making the system easier to extend and scale.

beginner

Give a real-life analogy for 'Program to interface, not implementation'.

Like using a TV remote control (interface) without caring about the brand or model (implementation). You just press buttons and expect it to work.

intermediate

How does programming to interface improve testing?

It allows using mock or fake implementations of interfaces during testing, making tests isolated and easier to write.

advanced

What is a common design pattern that supports programming to interface?

The Dependency Injection pattern, which injects implementations of interfaces into classes, promoting loose coupling.

What is the main advantage of programming to an interface?

A Allows changing implementations without affecting dependent code

B Makes code run faster

C Reduces the number of lines of code

D Eliminates the need for testing

Programming to an interface allows changing the underlying implementation without changing the code that uses it.

Which of these best describes an interface in programming?

A A contract defining methods without implementation

B A detailed class with full implementation

C A database schema

D A user interface design

An interface defines method signatures without implementation, acting as a contract.

How does programming to interface help in testing?

A By removing the need for tests

B By making tests run automatically

C By allowing use of mock implementations

D By making code shorter

Mock implementations of interfaces can be used to isolate tests from real dependencies.

Which design pattern is closely related to programming to interface?

A Singleton

B Factory

C Observer

D Dependency Injection

Dependency Injection provides implementations of interfaces to classes, supporting loose coupling.

What happens if you program directly to implementation instead of interface?

A Code becomes more flexible

B Code becomes tightly coupled and harder to change

C Code runs faster

D Code requires no documentation

Programming to implementation creates tight coupling, making changes difficult.

Explain the concept of 'Program to interface, not implementation' with a simple example.

Think about how using a remote control hides the TV details.

Describe how programming to interface improves system flexibility and testing.

Consider how changing parts without breaking others helps.

Practice

1. What is the main benefit of programming to an interface rather than a concrete implementation?

easy

A. It allows changing the implementation without affecting the code that uses it.

B. It makes the program run faster by using direct calls.

C. It reduces the number of lines of code needed.

D. It forces the use of only one implementation.

Solution

1. Step 1: Understand interface vs implementation

   Programming to an interface means using a contract that defines what methods are available, not how they work internally.

2. Step 2: Identify the benefit of this approach

   This allows swapping or changing the underlying implementation without changing the code that depends on the interface.

3. Final Answer:

   It allows changing the implementation without affecting the code that uses it. -> Option A

4. Quick Check:

   Interface abstraction = flexibility [OK]

Hint: Interfaces hide details, so implementations can change freely [OK]

Common Mistakes:

• Thinking it improves speed directly
• Believing it reduces code size automatically
• Assuming only one implementation is allowed

2. Which of the following code snippets correctly shows programming to an interface in a language like Java?

easy

A. List<String> list = new ArrayList<>();

B. ArrayList<String> list = new ArrayList<>();

C. List<String> list = new List<>();

D. ArrayList<String> list = new List<>();

Solution

1. Step 1: Identify interface and implementation

   In Java, List is an interface, and ArrayList is a concrete class implementing List.

2. Step 2: Check which declaration uses interface type

   Declaring the variable as List and instantiating with ArrayList means programming to interface, not implementation.

3. Final Answer:

   List<String> list = new ArrayList<>(); -> Option A

4. Quick Check:

   Variable type = interface [OK]

Hint: Use interface type on left side, implementation on right [OK]

Common Mistakes:

• Using concrete class on both sides
• Trying to instantiate an interface directly
• Mixing types incorrectly

3. Given the following code in a language supporting interfaces:

interface Vehicle { void drive(); }
class Car implements Vehicle { public void drive() { print("Car driving"); } }
class Bike implements Vehicle { public void drive() { print("Bike driving"); } }
Vehicle v = new Car();
v.drive();

What will be the output?

medium

A. Compilation error

B. Bike driving

C. Car driving

D. Vehicle driving

Solution

1. Step 1: Identify the object type assigned to interface variable

   The variable v of type Vehicle is assigned a new Car object.

2. Step 2: Determine which drive() method runs

   Calling v.drive() runs the Car's drive() method because the actual object is Car.

3. Final Answer:

   Car driving -> Option C

4. Quick Check:

   Interface variable calls actual object's method [OK]

Hint: Interface calls use actual object's method at runtime [OK]

Common Mistakes:

• Assuming interface method runs
• Confusing object type with variable type
• Expecting compilation error due to interface

4. Consider this code snippet:

interface Printer { void print(); }
class LaserPrinter implements Printer { void print() { System.out.println("Laser printing"); } }
Printer p = new LaserPrinter();
p.print();

Why does this code cause a compilation error?

medium

A. Interfaces cannot be instantiated.

B. LaserPrinter does not implement print() method.

C. Printer cannot be used as a variable type.

D. The print() method in LaserPrinter is not declared public.

Solution

1. Step 1: Check method visibility in implementation

   Interface methods are public by default, so implementing methods must be public.

2. Step 2: Identify method declaration in LaserPrinter

   LaserPrinter's print() method lacks the public modifier, causing a visibility mismatch error.

3. Final Answer:

   The print() method in LaserPrinter is not declared public. -> Option D

4. Quick Check:

   Interface methods require public implementation [OK]

Hint: Implement interface methods as public to avoid errors [OK]

Common Mistakes:

• Thinking interfaces can't be variable types
• Believing missing method causes error instead
• Ignoring method visibility rules

5. You are designing a payment system where multiple payment methods (CreditCard, PayPal, Crypto) can be used. To follow the principle 'Program to interface not implementation', which design is best?

hard

A. Write separate classes with no common interface and call their methods directly.

B. Create a PaymentMethod interface with a pay() method, and implement it in each payment class.

C. Use a single PaymentProcessor class with if-else to handle all payment types.

D. Make all payment classes inherit from a concrete PaymentProcessor class.

Solution

1. Step 1: Identify the need for abstraction

   Multiple payment types require a common contract to allow flexible usage.

2. Step 2: Choose design that uses interface

   Defining a PaymentMethod interface with pay() method lets each payment type implement its own logic while code depends only on the interface.

3. Final Answer:

   Create a PaymentMethod interface with a pay() method, and implement it in each payment class. -> Option B

4. Quick Check:

   Interface abstraction enables flexible, extendable design [OK]

Hint: Use interface for common behavior, implementations for details [OK]

Common Mistakes:

• Hardcoding payment types with if-else
• Not using interfaces for common behavior
• Using inheritance from concrete classes