July 6, 2023 by Garg

Have you ever been told that your code is “bad”? If so, you’re not alone. Every programmer, from novices to seasoned experts, has written flawed code at some point. But here’s the good news: there’s a roadmap to improvement, and it’s spelled S-O-L-I-D. These five SOLID Principles of programming design are your ticket to writing code that’s not just good, but great. Ready to embark on this journey? Let’s dive in.

SOLID Principles: Your Guide to Better Programming

SOLID is an acronym that stands for five crucial principles in programming: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. These principles, while simple in theory, can have a profound impact on your code. And while we’ll be using Java for our examples, rest assured that these principles apply to virtually any programming language.

Single Responsibility Principle (S): One Task, One Module

The Single Responsibility Principle is all about keeping things simple. Each module of your code should have one, and only one, responsibility. Consider a Person class that sends emails and calculates taxes. By splitting this class into smaller, more focused classes, we can make our code cleaner, more testable, and more reusable.

This principle states that a class should have only one reason to change. In other words, it should have only one job.

// Before
public class Employee {
public double calculateSalary() {
// calculate salary
}

public void saveEmployeeDetails() {
// save employee details
}
}

// After
public class Employee {
public double calculateSalary() {
// calculate salary
}
}

public class EmployeeDB {
public void saveEmployeeDetails(Employee e) {
// save employee details
}
}

In the above example, the Employee class initially had two responsibilities: calculating the salary and saving the employee details. We refactored it to follow the Single Responsibility Principle by moving the responsibility of saving employee details to a new class EmployeeDB.

Open/Closed Principle (O): Flexibility is Key

The Open/Closed Principle encourages us to design our modules so that they can be extended without being modified. This principle is all about future-proofing your code. By designing modules that are “open for extension but closed for modification,” we can add new functionality without breaking existing code.

This principle states that software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

public interface Shape {
double calculateArea();
}

public class Rectangle implements Shape {
private double length;
private double width;

// constructor, getters, and setters

@Override
public double calculateArea() {
return length * width;
}
}

public class Circle implements Shape {
private double radius;

// constructor, getters, and setters

@Override
public double calculateArea() {
return Math.PI * Math.pow(radius, 2);
}
}

In this example, Shape is an interface that is open for extension (we can add as many shapes as we want), and each shape class is closed for modification (we don’t need to modify them to add a new shape).

Liskov Substitution Principle (L): Interchangeability Matters

The Liskov Substitution Principle states that subclasses should be able to be used interchangeably with their super classes without breaking the functionality of the program. This principle ensures that our code remains flexible and easy to maintain.

This principle states that if a program is using a base class, then the reference to the base class can be replaced with a derived class without affecting the functionality of the program.

public class Bird {
public void fly() {
// implementation
}
}

public class Duck extends Bird {
@Override
public void fly() {
// implementation
}
}

In this example, Duck is a subclass of Bird and can be substituted anywhere a Bird object is expected, without altering the correctness of the program.

Interface Segregation Principle (I): Keep It Specific

The Interface Segregation Principle advises us to use specific interfaces rather than general ones. By breaking down our interfaces into smaller, more specific ones, we can ensure that our classes only depend on the interfaces they actually use.

This principle states that a client should never be forced to implement an interface that it doesn’t use.

public interface Flyable {
void fly();
}

public interface Quackable {
void quack();
}

public class Duck implements Flyable, Quackable {
@Override
public void fly() {
// implementation
}

@Override
public void quack() {
// implementation
}
}

In this example, Duck class only implements the interfaces that it needs (Flyable and Quackable), rather than a large Bird interface that might include methods it doesn’t need.

Dependency Inversion Principle (D): Depend on Abstractions

The Dependency Inversion Principle is all about reducing dependencies. High-level modules should not rely directly on low-level modules. Instead, both should rely on abstractions. This principle makes our code more flexible and easier to modify.

This principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions.

public interface Database {
void connect();
}

public class MySQLDatabase implements Database {
@Override
public void connect() {
// implementation
}
}

public class Project {
private Database database;

public Project(Database database) {
this.database = database;
}

public void start() {
database.connect();
}
}

In this example, the `Project` class does not depend on a specific database implementation (like `MySQLDatabase`). Instead, it depends on the `Database` interface, an abstraction. This allows us to easily switch to a different database implementation without changing the `Project` class. We can pass the specific database implementation we want to use when we create a `Project` object. This is an example of Dependency Injection, a common way to achieve Dependency Inversion.

Conclusion: The Power of SOLID

In the ever-evolving world of programming, the SOLID principles remain a cornerstone of good code design. While their benefits may not be immediately apparent in smaller applications, they become invaluable as projects scale. By promoting modularity and flexibility, SOLID principles lay the foundation for modern software architecture.

Ready to take your programming skills to the next level? Entrustech is here to help. Whether you’re looking to learn more about SOLID principles or are ready to make your next career move, we’re here to guide you every step of the way. Book an appointment or send us an email to get started on your journey to mastering SOLID and writing truly great code.