SOLID is a set of design heuristics. Single Responsibility encourages cohesive responsibilities. Open/Closed encourages extension without repeatedly modifying stable behavior. Liskov Substitution focuses on substitutability. Interface Segregation avoids irrelevant dependencies. Dependency Inversion encourages high-level policy to depend on abstractions.

interface NotificationSender {
    void send(String recipient, String message);
}

final class OrderService {
    private final NotificationSender sender;

    OrderService(NotificationSender sender) {
        this.sender = sender;
    }
}

The value is reduced coupling and easier testing, not creating an interface for every class.

Common patterns include Factory, Builder, Strategy, Adapter, Decorator, Observer, Template Method, Command, and State.

interface PricingStrategy {
    long price(Order order);
}

final class RegularPricing implements PricingStrategy {
    public long price(Order order) {
        return order.subtotal();
    }
}

Strategy is polymorphism used to select interchangeable behavior. Builder helps construct complex immutable objects. Adapter translates one interface into another. Decorator adds behavior without modifying the wrapped implementation.

Layered architecture commonly separates controllers, services, and repositories. Hexagonal architecture separates application/domain logic from external adapters through ports.

HTTP / Messaging / CLI
         |
      Adapters
         |
        Ports
         |
Application / Domain
         |
        Ports
         |
     DB / APIs / Files

The key idea is dependency direction: business rules should not be tightly coupled to HTTP frameworks, database drivers, or cloud SDKs.

A good domain model captures meaningful business invariants. Value objects are useful when a concept has identity-independent rules such as money, email addresses, coordinates, or date ranges.

public final class Money {
    private final BigDecimal amount;
    private final Currency currency;

    public Money(BigDecimal amount, Currency currency) {
        this.amount = amount;
        this.currency = currency;
    }
}

Avoid both extremes: scattering business rules everywhere and turning every simple CRUD operation into an elaborate framework.