Every good programming blog needs at least one post about SOLID principles, right? SOLID is a set of rules one should follow, when writing object-oriented code and yes - as junior developer I broke all of them many times. In this article I’m sharing my mistakes, so that you can learn and correct them yourself. To check proper implementation for each principle scroll to the very bottom.

S. - Single Responsibility Principle

In programming we try to divide our code into smaller parts, usually into modules, classes or functions, because then it’s easier to understand and maintain. During this process, the most basic criteria we should take into consideration is responsibility. Each module, class and function should do only one thing. Take a look at a common mistake I made when I was learning to code. Can you fix it?

public class Formatter {

    private WebAPIClient webAPIClient;
    private Logger logger;

    public Formatter(WebAPIClient webAPIClient, Logger logger) {
        this.webAPIClient = webAPIClient;
        this.logger = logger;
    }

    public void formatInputAndUploadResult(String input) {
        String formattedInput;
        if (input.length() > 5) {
            formattedInput = "LONG_INPUT_FROM_MOBILE_APP" + input.trim();
        } else {
            formattedInput = "SHORT_INPUT_FROM_MOBILE_APP" + input.trim();
        }
        webAPIClient.uploadData(formattedInput, new OnSuccessListener() {
            @Override
            public void onSuccess() {
                logger.log("Operation successful!");
            }
        });
    }
}

O. - Open-Closed Principle

In more complicated projects, whenever a developer modifies existing code, he takes a gamble that things will break in other places.

How can we mitigate this risk? Well, business requirements evolve all the time, so it’s not possible to just say “No” to a product manager, who asks for new additions to the feature we’ve just finished coding. The solution is to minimize changes to existing code in favor of extending it and building upon it. Do you remember what polymorphism is? It’ll help us here. Can you spot what’s wrong with below example and why? Imagine we need to add another user type. How can we make this code more maintainable then?

public class UserSavingManager {

    private Database database;
    private AdminFormatter adminFormatter;
    private OwnerFormatter ownerFormatter;
    private MemberFormatter memberFormatter;

    public UserSavingManager(Database database,
                             AdminFormatter adminFormatter,
                             OwnerFormatter ownerFormatter,
                             MemberFormatter memberFormatter) {
        this.database = database;
        this.adminFormatter = adminFormatter;
        this.ownerFormatter = ownerFormatter;
        this.memberFormatter = memberFormatter;
    }

    public void saveUserType(UserType userType, String data) {
        if (userType == UserType.ADMIN) {
            String formattedData = adminFormatter.format(data);
            database.save(formattedData);
        } else if (userType == UserType.OWNER) {
            String formattedData = ownerFormatter.format(data);
            database.save(formattedData);
        } else if (userType == UserType.MEMBER) {
            String formattedData = memberFormatter.format(data);
            database.save(formattedData);
        }
    }
}

public enum UserType {
    ADMIN, OWNER, MEMBER
}

public interface OwnerFormatter {

    String format(String data);
}

public interface MemberFormatter {

    String format(String data);
}

public interface AdminFormatter {

    String format(String data);
}

public interface Database {

    void save(String data);
}

L. - Liskov Substitution Principle

This rule again touches upon polymorphism (which we are achieving through inheritance). In essence, Liskov Substitution Principle forces us to rethink our abstractions (or simply: base classes, that we’re inheriting from). Why? Because whenever we use a class as a parent (e. g. class Bird) and we’re extending from it (class Eagle extends Bird, class Penguin extends Bird) we cannot forget, that each child class can be used interchangeably in every place the parent class is expected (e. g. function beginOverseasBirdMigration(Bird bird)can take both Eagle and Penguin classes). So if Bird class had abstract method fly(), returning a distance it flew after a day, and bird migration requires flying, what would a poor Penguin do? Penguins can’t fly, but they’re birds. And based on function beginOverseasBirdMigration(Bird bird), which inside itself calls fly() on each Bird object, they fit into this code perfectly and, in effect, everybody assumes they can migrate from one continent to the other. Unfortunately, implementation of fly() in Penguin always returns 0. Can you see a problem here? This abstraction (base class) does not make sense. Now let’s see real-life mistake I made numerous times in the past. I’m sure you can fix it.

public class GroupMember {

    void leaveGroup() {
        // Override inside each child class
    }
}

public class GroupAdmin extends GroupMember {

    @Override
    void leaveGroup() {
        // Admins are members and can leave a group any time
    }
}

public class GroupOwner extends GroupMember {

    @Override
    void leaveGroup() {
        // Owners are members, but if they leave group it will be deleted :(
    }
}

public class GroupController {

    public void forceMemberToLeave(GroupMember groupMember) {
        // Unexpected behavior: if group member is GroupOwner, then entire group is deleted!
        groupMember.leaveGroup();
    }
}

I. - Interface Segregation Principle

The main characteristic of an interface is that a class implementing it must also implement all of its methods. Creator and user (class) of an interface form a contract with each other and, believe me, it’s extremely helpful trait...which can become a burden. Most of the time badly designed code forces you to do things you don’t want to do. And implementing unwanted methods, forced by some BIG weird existing interface you must use, is typical example of that. The solution? Split big interface into few small ones and leave space for a choice about which one to implement - this is exactly what Interface Segregation Principle stands for. Can you do it?

public interface User {

    void changePassword();

    void browseInternet();
}

public class MainUser implements User {

    @Override
    public void changePassword() {
        // Here MainUser changes password
    }

    @Override
    public void browseInternet() {
        // Here MainUser browses internet
    }
}

public class GuestUser implements User {

    @Override
    public void changePassword() {
        // unused - guest user can't change password
    }

    @Override
    public void browseInternet() {
        // Here user browses internet
    }
}

D. - Dependency Inversion Principle

There are many ways to achieve beautiful concept of Dependency Inversion, but the one, which is the most common is Dependency Injection. Every complicated class you’ll create in the future will depend on many other classes, which in turn will depend on others etc. The core idea behind Dependency Injection is to combine all of these classes in a sweet plug-in design, where the point of contact (point of plugging) is usually constructor. It’s easy. Just don’t be selfish and let others decide, which implementations to use inside your class instead of hardcoding them internally and making them private :). You can do it by exposing every class that’s needed through constructor and simply saying “This is what I need. Now YOU give it to me!” (let’s hope that anyone listens). The primary advantage of this, so called, loose coupling is better testability, readability, maintainability and reusability. Check last common mistake below and repair the broken code.

public class BackgroundTasksManager {

    private BroadcastManager broadcastManager = new BroadcastManager();
    private InputFormatter inputFormatter = new InputFormatter();
    private Uploader uploader = new Uploader();

    public void executeInTheBackground(String rawInput) {
        String formattedInput = inputFormatter.format(rawInput);
        uploader.upload(formattedInput);
        broadcastManager.sendTaskCompletedBroadcast();
    }
}

SOLUTIONS

S. - Single Responsibility Principle

public class Formatter {

    public String formatInput(String input) {
        String formattedInput;
        if (input.length() > 5) {
            formattedInput = "LONG_INPUT_FROM_MOBILE_APP" + input.trim();
        } else {
            formattedInput = "SHORT_INPUT_FROM_MOBILE_APP" + input.trim();
        }
        return formattedInput;
    }
}

public class Uploader {

    private WebAPIClient webAPIClient;
    private Logger logger;

    public Uploader(WebAPIClient webAPIClient,
                    Logger logger) {
        this.webAPIClient = webAPIClient;
        this.logger = logger;
    }

    public void upload(String formattedInput) {
        webAPIClient.uploadData(formattedInput, new OnSuccessListener() {
            @Override
            public void onSuccess() {
                logger.log("Operation successful!");
            }
        });
    }
}

O. - Open-Closed Principle

interface UserSavingManager {

    void saveUserType(String data);
}

public class OwnerSavingManager implements UserSavingManager {

    private Database database;
    private OwnerFormatter ownerFormatter;

    public OwnerSavingManager(Database database,
                              OwnerFormatter ownerFormatter) {
        this.database = database;
        this.ownerFormatter = ownerFormatter;
    }

    @Override
    public void saveUserType(String data) {
        String formattedData = ownerFormatter.format(data);
        database.save(formattedData);
    }
}

public class MemberSavingManager implements UserSavingManager {

    private Database database;
    private MemberFormatter memberFormatter;

    public MemberSavingManager(Database database,
                               MemberFormatter memberFormatter) {
        this.database = database;
        this.memberFormatter = memberFormatter;
    }

    @Override
    public void saveUserType(String data) {
        String formattedData = memberFormatter.format(data);
        database.save(formattedData);
    }
}

public class AdminSavingManager implements UserSavingManager {

    private Database database;
    private AdminFormatter adminFormatter;

    public AdminSavingManager(Database database,
                              AdminFormatter adminFormatter) {
        this.database = database;
        this.adminFormatter = adminFormatter;
    }

    @Override
    public void saveUserType(String data) {
        String formattedData = adminFormatter.format(data);
        database.save(formattedData);
    }
}

L. - Liskov Substitution Principle

public interface CanLeaveGroup {

    void leaveGroup();
}

public class GroupMember {

}

public class GroupAdmin implements CanLeaveGroup {

    // Now we're using composition instead of inheritance
    private GroupMember groupMember;

    public GroupAdmin(GroupMember groupMember) {
        this.groupMember = groupMember;
    }

    @Override
    public void leaveGroup() {
        // Admins are members and can leave a group any time
    }
}

public class GroupOwner {

    // Now we're using composition instead of inheritance
    private GroupMember groupMember;

    public GroupOwner(GroupMember groupMember) {
        this.groupMember = groupMember;
    }
}

public class GroupController {

    public void forceMemberToLeave(CanLeaveGroup groupMember) {
        groupMember.leaveGroup();
    }
}

I. - Interface Segregation Principle

public interface User {

    void browseInternet();
}

public interface SuperUser extends User {

    void changePassword();
}

public class MainUser implements SuperUser {

    @Override
    public void changePassword() {
        // Here MainUser changes password
    }

    @Override
    public void browseInternet() {
        // Here MainUser browses internet
    }
}

public class GuestUser implements User {

    @Override
    public void browseInternet() {
        // Here user browses internet
    }
}

D. - Dependency Inversion Principle

public class BackgroundTasksManager {

    private BroadcastManager broadcastManager;
    private InputFormatter inputFormatter;
    private Uploader uploader;

    public BackgroundTasksManager(BroadcastManager broadcastManager,
                                  InputFormatter inputFormatter,
                                  Uploader uploader) {
        this.broadcastManager = broadcastManager;
        this.inputFormatter = inputFormatter;
        this.uploader = uploader;
    }

    public void executeInTheBackground(String rawInput) {
        String formattedInput = inputFormatter.format(rawInput);
        uploader.upload(formattedInput);
        broadcastManager.sendTaskCompletedBroadcast();
    }
}