SOLID Principles

Hello World! I thought to write about the SOLID principles of software engineering. Now, I know it sounds all serious and fancy but trust me, these principles are gonna make your code look slick and professional. So, let’s dive in and explore how the SOLID principles can take your coding skills to the next level!

Single Responsibility Principle (SRP)

Alright, so here’s the deal with SRP. It’s all about keeping things focused and organized. Imagine you got this class that’s doing a gazillion things, like adding customers to a database and sending out emails. That’s just too much for one class, dude! With SRP, you split up the responsibilities. One class handles adding customers and another class takes care of sending emails. It’s like having separate superheroes for different tasks — they each have their own superpowers!

class Customer {
    void addCustomer() {
        // Code to add a new customer to the database
    }
    
    void sendEmail() {
        // Code to send a welcome email to the customer
    }
}

In the above example, the Customer class violates SRP by handling both customer management and email sending responsibilities. It would be better to split these responsibilities into separate classes.

Open-Closed Principle (OCP)

Now, let’s talk about being open but closed. No, I’m not talking about relationships here! OCP is all about making your code flexible and ready for changes without messing up the existing stuff. You wanna be able to add new features without rewriting everything from scratch, right? So, you create these cool classes or interfaces that can be extended and modified without breaking the existing code. It’s like having a LEGO set where you can keep adding more pieces to create awesome new designs!

interface Shape {
    double calculateArea();
}

class Circle implements Shape {
    double radius;
    
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle implements Shape {
    double width;
    double height;
    
    public double calculateArea() {
        return width * height;
    }
}

In this example, the Shape interface and its implementations (e.g., Circle and Rectangle) follow the OCP. If you need to add a new shape, you can create a new class that implements the Shape interface without modifying the existing code.

Liskov Substitution Principle (LSP)

LSP might sound like a fancy name, but it’s actually super important. It’s all about making sure your subclasses can smoothly replace their parent classes without causing any unexpected glitches. So, if you got this square class that inherits from a rectangle class, you want them to play nice together. You don’t want weird stuff happening when you swap a square for a rectangle. It’s like having friends who can step in for each other without causing chaos!

class Rectangle {
    protected int width;
    protected int height;
    
    public void setWidth(int width) {
        this.width = width;
    }
    
    public void setHeight(int height) {
        this.height = height;
    }
    
    public int calculateArea() {
        return width * height;
    }
}

class Square extends Rectangle {
    public void setWidth(int width) {
        this.width = width;
        this.height = width;
    }
    
    public void setHeight(int height) {
        this.width = height;
        this.height = height;
    }
}

In this example, the Square class inherits from the Rectangle class, but it violates the LSP. The setWidth and setHeight methods in the Square class behave differently from the base class, leading to unexpected behaviour when substituting a Square object for a Rectangle object.

Interface Segregation Principle (ISP)

Alright, let’s break down ISP. It’s about keeping things simple and not overwhelming your code with unnecessary stuff. You don’t wanna force your classes to depend on interfaces they don’t even use. Instead, you create smaller, focused interfaces that contain only the methods needed for each class. It’s like having customized playlists on your phone — you don’t wanna shuffle through a thousand songs when you just want a specific vibe!

interface Printable {
    void print();
}

interface Scanable {
    void scan();
}

class AllInOnePrinter implements Printable, Scanable {
    public void print() {
        // Code to print a document
    }
    
    public void scan() {
        // Code to scan a document
    }
}

In this example, the Printable and Scanable interfaces follow ISP by providing specific methods that are tailored to the needs of clients. The AllInOnePrinter class can implement both interfaces without being forced to implement unnecessary methods.

Dependency Inversion Principle (DIP)

Last but not least, DIP is all about being flexible and avoiding tight dependencies. You wanna depend on abstractions, not concrete implementations. Think of it like being able to swap out different brands of soda in a vending machine. You don’t care which brand you get, as long as it’s a soda. So, your code in a way that allows you to easily switch between different implementations without causing chaos in your codebase.

interface MessageSender {
    void sendMessage(String message);
}

class EmailSender implements MessageSender {
    public void sendMessage(String message) {
        // Code to send an email
    }
}

class SMSSender implements MessageSender {
    public void sendMessage(String message) {
        // Code to send an SMS
    }
}

In this example, the MessageSender interface represents the abstraction, and the EmailSender and SMSSender classes depend on the abstraction. This allows for dependency inversion, where the higher-level components can depend on the abstraction rather than directly on the concrete implementations.

Alright, that’s the lowdown on the SOLID principles. By following these guidelines, you’ll be slaying the coding like a pro. Your code will be cleaner, more maintainable and easier to work with. So, embrace the SOLID principles and get ready to level up your coding skills. Happy coding, my fellow techies! Keep rockin’ it!

connect with me: lakinduw.me