Welcome to the Design Patterns and Principles Repository! This repository serves as a comprehensive collection of widely used design patterns and principles in software development, demonstrating best practices in software architecture and engineering. It aims to provide a practical guide to understanding and applying both patterns and principles to solve common challenges, creating flexible, reusable, and maintainable systems.
Instructions on how to set up the project on a local machine:
-
Clone the repository:
git clone git@github.com:TheCollinsByte/design-patterns-and-principles.git
-
Navigate to the project directory:
cd design-patterns-and-principles -
Ensure you have JDK version 21 installed. You can download it here.
-
Compile the project:
./gradlew build
-
Run the project:
./gradlew :{MODULE_NAME}:test -Dtest.verbose=true
This repository includes examples of commonly used design patterns, each with detailed explanations and code implementations. Design patterns are proven solutions to recurring problems in software design and are categorized here by their purpose:
- Abstract Factory
- Builder
- Factory Method
- Prototype
- Singleton
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
- Chain of Responsibility
- Command
- Interpreter
- Iterator
- Mediator
- Memento
- Observer
- State
- Strategy
- Template Method
- Visitor
- Thread Pool
- Executor
- Producer-Consumer
- Reactor
This section covers fundamental design principles, such as SOLID, that guide software development and promote robust, maintainable, and scalable code. Each principle includes explanations, examples, and best practices.
The SOLID principles represent core guidelines for object-oriented design:
- Single Responsibility Principle (SRP): A class should have only one reason to change, meaning it should only have one job or responsibility.
- Open/Closed Principle (OCP): Software entities (classes, modules, functions) should be open for extension but closed for modification.
- Liskov Substitution Principle (LSP): Subtypes should be substitutable for their base types without altering the correctness of the program.
- Interface Segregation Principle (ISP): Clients should not be forced to depend on interfaces they do not use. Split interfaces into smaller, specific ones.
- Dependency Inversion Principle (DIP): High-level modules should not depend on low-level modules; both should depend on abstractions.
Each principle has its dedicated folder within the repository containing code samples and documentation.
Contributions are Welcome! Please follow these steps:
- Fork the repository.
- Create a new branch (
git checkout -b name-dp-module) - Make your changes and commit them (
git commit -m "Design Pattern/Principle: ...") - Push to the branch (
git push origin name-dp-module). - Create a new Pull Request.
This project is licensed under the MIT License - see the LICENSE file for details.