If you don’t have much time, this table captures the core of the SOLID principles:<\/p>\n\n\n\n Before learning how to do it right, we need to know how to do it wrong.<\/p>\n\n\n\n Here are the violations of each principle:<\/p>\n\n\n\n Consider this code:<\/p>\n\n\n\n This class has more than one reason to change.<\/p>\n\n\n\n If you change the database, probably If you want to change the notification, probably Ideally, this Employee class need to do just one thing: Represent the employee’s information.<\/p>\n\n\n\n Consider this class:<\/p>\n\n\n\n This class has been evolving to support multiple types of employees. The calculateSalary method is a classic example of the open\/close principle.<\/p>\n\n\n\n Here is one possible fix to conform to the open\/close principle:<\/p>\n\n\n\n Your code violates the LSP when you declare a function that accepts a base class but cannot handle a sub-type of that base class. Let’s consider this example:<\/p>\n\n\n\n In this code, your watchBirdFly declares that it would accept any instance of the Bird class. However, it cannot handle a Penguin (which is a subtype of the Bird class).<\/p>\n\n\n\n The issue above was caused by using a *fat* interface. Instead of letting Penguin extend Bird, you need to create interfaces that represent the nature of birds more closely. For example, in this case, I would create a FlyingBird interface and a SwimmingBird interface that extend the Bird interface.<\/p>\n\n\n\n An Interface Segregation Principle (ISP) violation happens when a class is forced to implement an interface that includes methods it does not use or need. This will lead to bloated code, increased complexity, and a higher chance of bugs due to the implementation of irrelevant methods.<\/p>\n\n\n\n For example, you are implementing a Device interface. <\/p>\n\n\n\n As you can see, in this case, the printer is forced to implement the methods of fax and scan, which aren’t its function. <\/p>\n\n\n\n The solution for this violation would be to separate the MultiFunctionDevice into multiple interfaces:<\/p>\n\n\n\n Now, the SimplePrinter can implement only the function it supports. For a more complex device, all three functions are implemented. <\/p>\n\n\n\n Dependency Inversion Principle (DIP) says that high-level modules should not depend on low-level modules; both should depend on abstractions. In addition, abstractions should not depend on details; details should depend on abstractions. The purpose of this principle is to reduce the coupling between software modules to make systems easier to maintain and extend.<\/p>\n\n\n\n To understand this principle, we need to clarify that the level mentioned here is the level of abstraction. The high-level module is more generalized, and more abstract and the low-level modules are more specific, and closer to the implementation. <\/p>\n\n\n\n Take the following example:<\/p>\n\n\n\n Here, the high level module (Button) depends directly on the low level module Lamp. However, a Lamp is not the only module that the button can action. We can switch on and off a fan or a laptop, for example. Thus the Button module should depend on the abstraction of the switch on\/off function. <\/p>\n\n\n\n This code fixes the violation:<\/p>\n\n\n\n Here, by defining an interface called Switchable, the Button module can act on any low-level module that implements this interface, not just the Lamp module. <\/p>\n\n\n\n In this post, I introduced you to the SOLID principles. I also gave examples of the violations of each principle and how to fix them.<\/p>\n","protected":false},"excerpt":{"rendered":"Principle<\/th> Description<\/th><\/tr><\/thead> Single Responsibility Principle (SRP)<\/td> Clients should not be forced to depend on interfaces they do not use. This principle promotes the idea of small, focused interfaces instead of large, monolithic interfaces. Clients should only be exposed to the methods they require, reducing the impact of changes and increasing reusability. One example is having an interface called Bird<\/code> and a method fly<\/code> then creating a Duck<\/code> class implementing that interface. Obviously, Duck cannot fly. A better design is to create Flyable<\/code> and Unflyable<\/code> interfaces extending Bird<\/code> and make Duck<\/code> implement Unflyable<\/code><\/td><\/tr>Open\/Closed Principle (OCP)<\/td> A class should have only one reason to change<\/em>. That means a class should have only one responsibility or job and not be responsible for multiple unrelated tasks. The purpose is to achieve high cohesion and maintainability.<\/td><\/tr> Liskov Substitution Principle (LSP)<\/td> Subtypes must be substitutable for their base types. It ensures that objects of a superclass can be replaced with objects of its subclasses without affecting the correctness of the program. <\/td><\/tr> Interface Segregation Principle (ISP)<\/td> Clients should not be forced to depend on interfaces they do not use. This principle promotes the idea of small, focused interfaces instead of large, monolithic interfaces. Clients should only be exposed to the methods they require, reducing the impact of changes and increasing reusability. One example is having an interface called Bird<\/code> and a method fly<\/code> then creating a Duck<\/code> class implementing that interface. Obviously Duck cannot fly. A better design is to create Flyable<\/code> and Unflyable<\/code> interfaces extending Bird<\/code> and make Duck<\/code> implement Unflyable<\/code><\/td><\/tr>Dependency Inversion Principle (DIP)<\/td> High-level modules should not depend on low-level modules. Both should depend on abstractions. It promotes loose coupling and decoupling between modules by introducing abstractions (interfaces or abstract classes) that define the contract between them. Dependencies should be based on abstractions rather than concrete implementations.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n SOLID principles violations<\/h2>\n\n\n\n
Single Responsibility violation<\/h3>\n\n\n\n
public class Employee {\n private String name;\n private double salary;\n\n public void calculateSalary() {\n \/\/ Code to calculate the salary\n }\n\n public void saveToDatabase() {\n \/\/ Code to save the employee details to the database\n }\n\n public void sendNotification() {\n \/\/ Code to send a notification to the employee\n }\n}\n<\/pre><\/div>\n\n\n\nsaveToDatabase<\/code> need to change.<\/p>\n\n\n\nsendNotification<\/code> need to change.<\/p>\n\n\n\nOpen\/Close Violation<\/h3>\n\n\n\n
public class Employee {\n private String name;\n private double salary;\n private String type;\n\n public double calculateSalary() {\n if (type.equals("FullTime")) {\n \/\/ Calculation logic for full-time employees\n } else if (type.equals("PartTime")) {\n \/\/ Calculation logic for part-time employees\n } else if (type.equals("Contractor")) {\n \/\/ Calculation logic for contractors\n }\n \/\/ ...\n }\n}\n<\/pre><\/div>\n\n\n\nOpen\/Close Violation’s Fix<\/h3>\n\n\n\n
public abstract class Employee {\n private String name;\n private double salary;\n\n public abstract double calculateSalary();\n}\n\npublic class FullTimeEmployee extends Employee {\n \/\/ Implementation of calculateSalary() for full-time employees\n}\n\npublic class PartTimeEmployee extends Employee {\n \/\/ Implementation of calculateSalary() for part-time employees\n}\n\npublic class ContractorEmployee extends Employee {\n \/\/ Implementation of calculateSalary() for contractors\n}\n<\/pre><\/div>\n\n\n\nLiskov Substitution Principle’s Violation<\/h3>\n\n\n\n
interface Bird {\n void fly();\n}\n\nclass Penguin implements Bird {\n @Override\n void fly() {\n throw new UnsupportedOperationException("Penguins can't fly!");\n }\n \n void swim() {\n System.out.println("I can swim!");\n }\n}\n\nclass TestBird {\n \n \n public void watchBirdFly(Bird bird) {\n bird.fly();\n }\n \n \n public static void main(String[] args) {\n \tvar penguin = new Penguin();\n watchBirdFly(penguin);\/\/Throws an exception\n }\n}\n<\/pre><\/div>\n\n\n\nLiskov Substitution Principle’s Violation’s Fix<\/h3>\n\n\n\n
interface Bird {\n}\ninterface FlyingBird {\n void fly();\n}\n\ninterface SwimmingBird {\n void swim(); \n}\n\nclass Penguin implements SwimmingBird {\n\n\t@Override \n void swim() {\n System.out.println("I can swim!");\n }\n}\n\nclass TestBird {\n \n \n public void watchBirdFly(FlyingBird bird) {\n bird.fly();\n }\n public void watchBirdSwim(SwimmingBird bird) {\n bird.swim();\n }\n \n public static void main(String[] args) {\n \tvar penguin = new Penguin();\n watchBirdSwim(penguin);\/\/Works fine\n }\n}\n<\/pre><\/div>\n\n\n\nInterface Segregation Principle’s Violation<\/h3>\n\n\n\n
interface MultiFunctionDevice {\n void print();\n void scan();\n void fax();\n}\n\nclass SimplePrinter implements MultiFunctionDevice {\n public void print() {\n \/\/ Printing logic\n System.out.println("Print document");\n }\n\n public void scan() {\n \/\/ Not supported, but still has to be implemented\n throw new UnsupportedOperationException("Scan not supported");\n }\n\n public void fax() {\n \/\/ Not supported, but still has to be implemented\n throw new UnsupportedOperationException("Fax not supported");\n }\n}\n<\/pre><\/div>\n\n\n\ninterface Printer {\n void print();\n}\n\ninterface Scanner {\n void scan();\n}\n\ninterface Fax {\n void fax();\n}\n\nclass SimplePrinter implements Printer {\n public void print() {\n \/\/ Printing logic\n System.out.println("Print document");\n }\n}\n\nclass MultiFunctionPrinter implements Printer, Scanner, Fax {\n public void print() {\n \/\/ Print logic\n System.out.println("Print document");\n }\n\n public void scan() {\n \/\/ Scan logic\n System.out.println("Scan document");\n }\n\n public void fax() {\n \/\/ Fax logic\n System.out.println("Fax document");\n }\n}\n\n<\/pre><\/div>\n\n\n\nDependency Inversion Principle’s violation<\/h3>\n\n\n\n
class Lamp {\n public void turnOn() {\n System.out.println("Lamp turned on");\n }\n\n public void turnOff() {\n System.out.println("Lamp turned off");\n }\n}\n\nclass Button {\n private Lamp lamp;\n\n public Button(Lamp lamp) {\n this.lamp = lamp;\n }\n\n public void toggle() {\n \/\/ Some toggle logic\n \/\/ This directly couples the Button to a Lamp, violating DIP\n lamp.turnOn();\n \/\/ ...\n lamp.turnOff();\n }\n}\n<\/pre><\/div>\n\n\n\n\/\/ Abstraction that both high-level and low-level modules depend on\ninterface Switchable {\n void turnOn();\n void turnOff();\n}\n\n\/\/ Low-level module implementation\nclass Lamp implements Switchable {\n public void turnOn() {\n System.out.println("Lamp turned on");\n }\n\n public void turnOff() {\n System.out.println("Lamp turned off");\n }\n}\n\n\/\/ High-level module\nclass Button {\n private Switchable device; \/\/ Depends on abstraction, not on concrete Lamp\n\n public Button(Switchable device) {\n this.device = device;\n }\n\n public void toggle() {\n \/\/ Toggle logic\n \/\/ Can turn on\/off any device, not just a lamp\n device.turnOn();\n \/\/ ...\n device.turnOff();\n }\n}\n\n\/\/ Usage\nSwitchable myLamp = new Lamp();\nButton button\n<\/pre><\/div>\n\n\n\nConclusion<\/h2>\n\n\n\n