Object Oriented Design

In object-oriented programming, Facade is a structural design pattern that simplifies the interaction between the client and complex subsystem. For this, we design a facade class that works as an interface between the client and interdependent classes in the subsystem. In other words, the facade class is a wrapper class, which encapsulates the complexity of the subsystem.

Requirement gathering is the process of collecting and documenting the needs, expectations, and constraints of stakeholders to develop software. On the other hand, Use cases are used in software development to capture and describe the functional requirements of a system. In this blog, we will discuss how to capture requirements properly and write good use cases for developing good software.

We use the idea of message passing in both object-oriented programming as well as concurrent programming. In OOPS, message passing is a way for objects to communicate within a program. Similarly, in concurrent programming, we use it to communicate messages between processes or threads. In this blog, we will discuss how message passing works in OOPS.

In object-oriented programming, Proxy is a structural design pattern that provides a placeholder for another object to control its access. Here proxy object works as an intermediary between the client and the real object so that the client will interact with the proxy instead of the real object.

In object-oriented programming (OOP), the concepts of cohesion and coupling are used to assess the quality of code and ensure it is maintainable and scalable. Cohesion and coupling are interdependent concepts and the goal is to attain high cohesion and low coupling. This will improve the overall maintainability, scalability, and readability of the code.

In object oriented programming, open closed principle states that: software entities (classes, modules, etc.) should be open for extension but closed for modification i.e. such an entity can extend its behavior without modifying its source code. This principle allows us to use the power of abstraction and inheritance to create such systems.