Object Oriented design principles is quite popular among software developers although hardly anyone follows or acknowledges the benefits of the same. OOP design principles add value to the knowledge and experience you have gained as a Java developer. Apache and Sun are leading examples of OOP design principles and how they could be used to code in a more efficient way.
Today let us look closer into the OOP design principles and the advantages it has to offer for Java development service provider to improve their skills and expertise while coding.
- DRY – Don’t Repeat Yourself:
This is a principle that every Java developer must follow diligently. DRY or Don’t Repeat Yourself principle means not writing the same code again and again for different functionality. Developers tend to use a common code to validate different functionality which joins them together forever and doesn’t allow any space to incorporate future changes in the functionalities.
- Encapsulate the Changes:
Change is inevitable, also in the software coding. Benefit of OOPs design principle is that it implies a lot of flexibility in programming and incorporating new product or objects in the future without impacting the existing code. Thus, leaving enough ground to accumulate the changes in future, OOPs design principle improves testing and maintenance of codes.
- Open Closed Principle
This is another major breakthrough in Java coding standards. OOPs design principle states that classes, methods or functions should be open to extend and add-on new functionalities in future, but should remain closed for modification. Thus, saving the trouble of testing already tested codes repeatedly unless one adds a new functionality to it.
- Single Responsibility Principle(SRP):
SRP states that there should not be more than one functionality in a single class in Java. Inputting more than one function into a class will lead to coupling more functions along with it and if you wish to make changes in a single function, all other associated functions in the same class would get changed. Thus, SRP restricts undesired changes in various classes of a Java code.
- Dependency Injection or Inversion Principle:
When DI framework injects a class, it gets easy to test with mock objects and equally convenient to maintain as the framework centralizes object creation code and client code with that.
- Favour Composition Over Inheritance:
Again it’s prioritizing code flexibility. Composition allows to change the behaviour of a class at runtime by setting property and using interfaces to compose a class. So, it is always apt to favour composition over inheritance.
- Liskov Substitution Principle:
Liskov Substitution Principle states that subtypes must be substitutable for super types. It means any method or function that uses super class type must be able to work with object of sub class without any hindrance or manipulation.
- Interface Segregation Principle(ISP):
Interface design in Java is a troublesome job as once the interface is released, one cannot change it without changing the implementations. So, ISP states that a client should not implement an interface if it doesn’t use it.
- Programming For Interface and Not Implementation:
This is blindly followed principle as this will lead to adaptable and flexible codes that will work on any given interface. Thus, it is always recommended to use interface on variables, return type of methods or argument type method in Java.
- Delegation Principle
Delegation Principle mostly means sharing of responsibilities. While comparing two objects for equality the class itself is asked to do the job instead of involving the client class to check into each little thing. This benefits in unique code retention and easy modifications.
Comments