Java Solid Principles

The SOLID principles are five design principles for writing maintainable and scalable software. They were introduced by Robert C. Martin and are widely used in object-oriented programming. The SOLID principles are:

1. Single Responsibility Principle (SRP)

Name	Description	Syntax	Example
SRP	A class should have only one reason to change.	class Car { … }	A Car class should have only the responsibilities related to the car, such as driving and fueling, but not the responsibilities of a parking lot, such as managing parking spots.

2. Open/Closed Principle (OCP)

Name	Description	Syntax	Example
OCP	Software entities should be open for extension but closed for modification.	interface Shape { … } class Circle implements Shape { … } class Rectangle implements Shape { … }	A Shape interface can be extended to support new shapes, but the existing code does not need to be modified.

3. Liskov Substitution Principle (LSP)

Name	Description	Syntax	Example
LSP	Subtypes must be substitutable for their base types.	interface Shape { … } class Circle implements Shape { … } class Rectangle implements Shape { … }	A Rectangle and a Circle can be used interchangeably, as they both implement the Shape interface.

4. Interface Segregation Principle (ISP)

Name	Description	Syntax	Example
ISP	Clients should not be forced to depend on interfaces they do not use.	interface Printable { … } interface Scanable { … } interface Faxable { … } class Printer implements Printable, Scanable { … }	A Printer class implements only the interfaces it needs, such as Printable and Scanable, but not Faxable.

5. Dependency Inversion Principle (DIP)

Name	Description	Syntax	Example
DIP	High-level modules should not depend on low-level modules. Both should depend on abstractions.	interface Engine { … } class GasEngine implements Engine { … } class ElectricEngine implements Engine { … } class Car { private Engine engine; … }	A Car class depends on an abstraction, the Engine interface, and not on concrete implementations, such as GasEngine or ElectricEngine.

By following these principles, developers can write cleaner, more maintainable, and scalable code.