Encapsulation and information hiding in LLD - Architecture Diagram

System Overview - Encapsulation and information hiding

This system demonstrates encapsulation and information hiding in software design. It shows how internal details of a module are hidden from users, exposing only necessary interfaces. The goal is to protect data integrity and reduce complexity for users.

Architecture Diagram

  +------------+       +----------------+       +------------+
  |   Client   | ----> |  Public API     | ----> | Internal   |
  | (User)    |       |  (Interface)    |       | Module     |
  +------------+       +----------------+       +------------+
                                   |                    |
                                   |                    v
                                   |             +------------+
                                   |             | Private    |
                                   |             | Data &     |
                                   |             | Methods    |
                                   |             +------------+

Components

Client

user

Sends requests to the system using the public interface

Public API

interface

Exposes only necessary methods to the client, hides internal details

Internal Module

module

Contains core logic and data, not directly accessible by client

Private Data & Methods

data_store

Stores sensitive data and helper functions hidden from client

Request Flow - 5 Hops

Client → Public API

Public API → Internal Module

Internal Module → Private Data & Methods

Internal Module → Public API

Public API → Client

Failure Scenario

Component Fails:Public API

Impact:Client cannot access any functionality since the public interface is down

Mitigation:Implement redundancy or fallback interfaces to maintain availability

Architecture Quiz - 3 Questions

Which component hides the internal data and methods from the client?

A Internal Module

B Client

C Public API

D Private Data & Methods

Design Principle

This architecture shows encapsulation by exposing only a public interface to clients while hiding internal data and methods. It protects data integrity and simplifies client interaction by information hiding.