Examine interface designs

5 minutes

Suppose there are many programmers developing a library management system, and two programmers are tasked with managing borrowable books. Mahmud, one of the programmers, designs a class called BorrowableBook with methods for borrowing and returning books. Mahmud creates a method named Borrow to allow users to borrow a book and another method named Return to handle returning it. These methods ensure that the availability of the book is properly tracked and provide clear feedback to the user.

Yara, another developer, is unaware of Mahmud's efforts. Yara creates a similar class but uses different naming conventions, such as Checkout and GiveBack. This inconsistency can cause confusion and frustration for other programmers working on the project, as they need to learn different method names for similar functionality.

If methods for managing books are defined consistently, then programmers can quickly learn how to use them. They don't have to relearn how to borrow or return a book each time they encounter a new class. Establishing code standards up front helps to simplify your project code and make it easier to maintain.

Coding standards

Code standardization means creating and following a set of rules for writing code. These rules help keep code consistent and easy to read across a project. When everyone follows the same rules, it's easier for different programmers to understand and work with each other's code. Standardization also helps to prevent mistakes, improve the quality of the code, and make it quicker to check code for errors.

Using interfaces can help establish code standardization, since interfaces act as contracts for the code. When you define an interface, you assert that any class using that interface must have certain methods and properties. Using interfaces can also help prevent tightly coupled code, which allows you to better adhere to design standards.

SOLID design principles

SOLID is an acronym for five design principles of object-oriented programming, and interfaces are a crucial element of these principles. The SOLID principles of design are:

Single Responsibility Principle (SRP): A class should focus on one clear job and handle it completely. Therefore, a class should only change for one specific reason.
Open/Closed Principle (OCP): A class should be open for extension but closed for modification. In other words, you should be able to add new functionality to a class without changing its existing code.
Liskov Substitution Principle (LSP): Subtypes should be substitutable for their base types. In other words, if a program is written to work with a certain type of object, any subtype of that object should be able to replace it without causing errors.
Interface Segregation Principle (ISP): Classes shouldn't be forced to depend on interfaces they don't use. Instead, interfaces should be designed to provide only the functionality that classes need.
Dependency Inversion Principle (DIP): Rather than classes depending on other components directly, they should instead depend on interfaces or abstract classes that define the required behavior. The abstraction of behavior definition allows for greater flexibility and modularity in a project, as changes to one component don't affect the others.

By following these principles, developers can create software that is easier to modify, test, and maintain, with looser coupling and better cohesion between components. The SOLID principles are widely used in object-oriented programming and are considered a best practice in software development.

Choose the best response for each of the questions below.

Feedback

Was this page helpful?

Examine interface designs

Check your knowledge

Feedback