The Object-Oriented Design Principles are the core of OOP programming, but I have seen most of the Java programmers chasing design patterns like [Singleton pattern](https://javarevisited.blogspot.com/2014/05/double-checked-locking-on-singleton-in-java.html), [Decorator pattern](http://www.java67.com/2013/07/decorator-design-pattern-in-java-real-life-example-tutorial.html), or [Observer pattern](http://javarevisited.blogspot.sg/2011/12/observer-design-pattern-java-example.html), and not putting enough attention on learning _Object-oriented analysis and design_.\n\nIt’s important to learn the basics of Object-oriented programming like [Abstraction](https://javarevisited.blogspot.com/2017/04/difference-between-abstraction-and-encapsulation-in-java-oop.html), [Encapsulation](https://javarevisited.blogspot.com/2012/03/what-is-encapsulation-in-java-and-oops.html), [Polymorphism](http://javarevisited.blogspot.sg/2011/08/what-is-polymorphism-in-java-example.html), and [Inheritance](http://www.java67.com/2016/03/top-21-java-inheritance-interview-Questions-Answer-Programming.html). But, at the same time, it’s equally important to know object-oriented design principles.\n\n> They will help you to create a clean and modular design, which would be easy to test, debug, and maintain in the future.\n\nI have regularly seen Java programmers and developers of various experience level, who have either never heard about these [OOP](http://www.java67.com/2015/12/top-30-oops-concept-interview-questions-answers-java.html) and [SOLID design principle](https://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fprinciples-oo-design)**,** or simply doesn’t know what benefits a particular design principle offers and how to apply these design principle in coding.\n\nTo do my part, I have jotted down all important object-oriented design principles and putting it here for quick reference. These will at least give you some idea about what they are and what benefit they offer. \n \nI have not put examples, just to keep the article short but you can find a lot of examples of these design principles on the internet and even on my [**Java blog**](http://javarevisited.blogspot.com/), just use the search bar at the top of the page. \n \nIf you are not able to understand a design principle, you should try to do more than one example because sometimes we connect to another example or author better but you must understand these design principles and learn how to use it in your code. \n \nAnother thing you can do is to join a comprehensive object-oriented design course like [**SOLID Principles of Object-Oriented Design**](https://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fprinciples-oo-design) by Steve Smith on Pluralsight. It has helped me a lot in my understanding and application of these principles.\n\nBtw, I have shared some relevant and useful courses and books here and there, both free and paid, and I will earn some money if you buy something which is not free.\n\nThey are also some of the resources I have used to learn SOLID design principles and Programming in general and nice for learning some of these principles in depth.\n\n### 10 Object Oriented and SOLID Desing Principles for Programmers\n\nThough the best way of learning any design principle or pattern is a real-world example and understanding the consequences of violating that design principle, subject of this article is Introducing [_Object-oriented design principles_](https://hackernoon.com/top-5-object-oriented-programming-and-design-courses-for-programmers-ad49f0870de4?source=user_profile---------7---------------------) for Java Programmers, who are either not exposed to it or in the learning phase.\n\n!(https://cdn-images-1.medium.com/max/640/0*hFHcemaDZkAM6U3Y.png)\n\nI personally think each of these [OOP](https://medium.com/swlh/5-free-object-oriented-programming-online-courses-for-programmers-156afd0a3a73) and [SOLID design principles](https://javarevisited.blogspot.com/2018/02/top-5-java-design-pattern-courses-for-developers.html) needs an article to explain them clearly, and I will definitely try to do that here, but for now, just get yourself ready for a quick bike ride on design principle town :)\n\n### 1\\. DRY (Don’t repeat yourself)\n\nOur first object-oriented design principle is DRY, as the name suggests **DRY (don’t repeat yourself)** means don’t write duplicate code, instead use [Abstraction](http://javarevisited.blogspot.com/2010/10/abstraction-in-java.html) to abstract common things in one place.\n\nIf you have a block of code in more than two places consider making it a separate method, or if you use a hard-coded value more than one time make them [public final constant](http://javarevisited.blogspot.com/2011/12/final-variable-method-class-java.html). The benefit of this Object oriented design principle is in **maintenance**.\n\n> It’s important not to abuse it, duplication is not for code, but for functionality.\n\nIt means if you have used common code to validate OrderId and SSN it doesn’t mean they are the same or they will remain the same in future.\n\n[!(https://cdn-images-1.medium.com/max/400/0*I9HuckIG9IxgL_a0.jpg)](https://click.linksynergy.com/fs-bin/click?id=JVFxdTr9V80&subid=0&offerid=562016.1&type=10&tmpid=14538&RD_PARM1=https%3A%2F%2Fwww.udemy.com%2Fbasics-of-software-architecture-design-in-java%2F)\n\nBy using common code for two different functionality or thing you closely couple them forever and when your OrderId changes its format, your SSN validation code will break. \n \nSo beware of such coupling and just don’t combine anything which uses the similar code but are not related. You can further check out the [**Basics of Software Architecture & Design Patterns**](https://click.linksynergy.com/fs-bin/click?id=JVFxdTr9V80&subid=0&offerid=562016.1&type=10&tmpid=14538&RD_PARM1=https%3A%2F%2Fwww.udemy.com%2Fbasics-of-software-architecture-design-in-java%2F) in Java course on Udemy to learn more about writing good code and best practices to follow while designing a system.\n\n### 2\\. Encapsulate What Changes\n\nThere is only one thing which is constant in the software field and that is “Change”, So, encapsulate the code you expect or suspect to be changed in future.\n\n> The benefit of this OOP Design principle is that It’s easy to test and maintain proper encapsulated code.\n\nIf you are coding in Java then follow the principle of [making variable and methods private](http://javarevisited.blogspot.sg/2012/03/private-in-java-why-should-you-always.html#axzz559dyoLSA) by default and increasing access step by step like from a private to [protected](http://www.java67.com/2012/12/what-is-public-private-protected-package-default-private-access-modifier-java.html) and not [public](https://javarevisited.blogspot.com/2012/10/difference-between-private-protected-public-package-access-java.html#axzz5Y4Koqgj5).\n\n[!(https://cdn-images-1.medium.com/max/320/0*sa7MD5_9K7a2euoU.jpg)](https://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fpatterns-library)\n\nSeveral of the **design patterns in Java** uses Encapsulation, the [Factory design pattern](http://javarevisited.blogspot.com/2011/12/factory-design-pattern-java-example.html) is one example of Encapsulation which encapsulates object creation code and provides flexibility to introduce a new product later with no impact on existing code. \n \nBtw, if you are interested in learning more about design patterns in Java and Object Oriented Programming then you must check this [**Design Pattern Library**](https://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fpatterns-library) course Pluralsight. It’s one of the best collection of design patterns and advice on how to use them in the real world.\n\n### 3\\. Open Closed Design Principle\n\nAccording to tho this OOP design principle, “Classes, methods or functions should be Open for extension (new functionality) and Closed for modification”.\n\nThis is another beautiful SOLID design principle, coined by Uncle Bob on his classic [**Clean Code**](http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882?tag=javamysqlanta-20) book, which prevents someone from changing already tried and tested code.\n\n> The key benefit of this design principle is that already tried and tested code is not touched which means they won’t break.\n\nHere is a Java code example which _violates_ the Open Closed Design Principle of Programming:\n\n[!(https://cdn-images-1.medium.com/max/1024/1*GQfvM7PxzIqhqATZKOf5tA.jpeg)](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fbasics-of-software-architecture-design-in-java%2F)\n\nIn this code GraphicEditor is tightly coupled with Shape, If you need a new Shape then you need to modify already tried and tested code inside thedrawShape(Shape s) method, which is both error-prone and not desirable.\n\nIdeally, if you are adding new functionality only than your code should be tested and that’s the goal of [Open Closed Design principle](http://javarevisited.blogspot.com/2011/11/great-example-of-open-closed-design.html).\n\nBy the way, the Open-Closed principle is “O” from the SOLID acronym. If you want to learn more about this principle, the [**SOLID Principles of Object-Oriented Design and Architecture**](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fsolid-principles-object-oriented-design-architecture%2F) course on Udemy is one of the best resources to consult.\n\n### 4\\. Single Responsibility Principle (SRP)\n\nSingle Responsibility Principle is another SOLID design principle, and represent “S” on the SOLID acronym. As per SRP, there should not be more than one reason for a class to change, or a class should always handle single functionality.\n\n> The key benefit of this principle is that it reduces coupling between the individual component of the software and Code.\n\nFor example, If you put more than one functionality in one Class in Java it introduces **coupling** between two functionality and even if you change one functionality there is a chance you broke coupled functionality, which requires another round of testing to avoid any surprise on the production environment. \n \nYou can further see [**From 0 to 1: Design Patterns — 24 That Matter**](https://click.linksynergy.com/fs-bin/click?id=JVFxdTr9V80&subid=0&offerid=323058.1&type=10&tmpid=14538&RD_PARM1=https%3A%2F%2Fwww.udemy.com%2Ffrom-0-to-1-design-patterns%2F) course on Udemy to learn about patterns which are based on this principle.\n\n[!(https://cdn-images-1.medium.com/max/400/0*ND11FPv3yREYc0mT.jpg)](https://click.linksynergy.com/fs-bin/click?id=JVFxdTr9V80&subid=0&offerid=323058.1&type=10&tmpid=14538&RD_PARM1=https%3A%2F%2Fwww.udemy.com%2Ffrom-0-to-1-design-patterns%2F)\n\n### 5\\. Dependency Injection or Inversion principle\n\nDon’t ask for dependency it will be provided to you by the framework. This has been very well implemented in [Spring framework](http://www.java67.com/2017/11/top-5-free-core-spring-mvc-courses-learn-online.html), one of the most popular Java framework for writing real-worth applications.\n\n> The beauty of this **design principle** is that any class which is injected by DI framework is **easy to test** with the mock object and easier to maintain because object creation code is centralized in the framework and client code is not littered with that.\n\nThere are multiple ways to implemented [**Dependency injection**](http://javarevisited.blogspot.com/2012/12/inversion-of-control-dependency-injection-design-pattern-spring-example-tutorial.html) like using bytecode instrumentation which some AOP (Aspect Oriented programming) framework like AspectJ does or by using proxies just like used in Spring.\n\nYou can further see the [**SOLID Principles of Object-Oriented Design and Architecture**](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fsolid-principles-object-oriented-design-architecture%2F) course on Udemy to learn more about this useful principle. It also represents “D” on the SOLID acronym.\n\nHere is an example of the code which violates Dependency Inversion Principle or DIP in Java:\n\n[!(https://cdn-images-1.medium.com/max/1024/1*5MUhO6vdyh-HrZRXLzaYWw.jpeg)](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fsolid-principles-object-oriented-design-architecture%2F)\n\nYou can see that AppManager depends upon EventLogWriter which is tightly coupled with the AppManager. If you need to use another way to notify your client like by sending push notifications, SMS, or E-mail, you need to change the AppManager class.\n\nThis problem can be solved by using the Dependency Inversion Principle where instead of AppManager asking for EventLogWriter, it will be injected or provided to AppManager by the framework.\n\nYou can further see [Using SOLID Principles to Write Better Code — A Crash Course](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2F1-hour-crash-course-using-solid-to-write-better-code%2F) on Udemy to learn more about the Dependency Inversion Principle and how to solve such problems.\n\n### 6\\. Favor Composition over Inheritance\n\nThere are two general ways to reuse the code you have already written, Inheritance and Composition, both have their own advantage and disadvantages, but, in general, you should always favor composition over inheritance, if possible.\n\n> Some of you may argue this, but I found that [Composition](https://javarevisited.blogspot.com/2014/02/ifference-between-association-vs-composition-vs-aggregation.html#axzz5bnktTXS4) is the lot more flexible than [Inheritance](http://javarevisited.blogspot.sg/2012/10/what-is-inheritance-in-java-and-oops-programming.html).\n\nComposition allows changing the behavior of a class at run-time by setting property during run-time and by using Interfaces to compose a class we use [polymorphism](http://javarevisited.blogspot.com/2011/08/what-is-polymorphism-in-java-example.html) which provides flexibility to replace with better implementation any time.\n\nEven Joshua Bloch’s [**Effective Java**](https://www.amazon.com/Effective-Java-3rd-Joshua-Bloch/dp/0134685997/?tag=javamysqlanta-20) advise favoring composition over inheritance. If you are still not convinced then you can also read [here](http://javarevisited.blogspot.sg/2015/06/difference-between-inheritance-and-Composition-in-Java-OOP.html) to learn more about why your Composition is better than Inheritance for reusing code and functionality.\n\nAnd, if you keep forgetting this rule, here is a nice cartoon to put in your desk :-)\n\n[!(https://cdn-images-1.medium.com/max/400/0*02XTt4MRsd_wMkj6.png)](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=40328&murl=https%3A%2F%2Fwww.coursera.org%2Flearn%2Fobject-oriented-java)\n\nIf you are interested in learning more about Object Oriented Programming Concepts like Composition, Inheritance, Association, Aggregation, etc, you can also take a look at the [Object-Oriented Programming in Java](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=40328&murl=https%3A%2F%2Fwww.coursera.org%2Flearn%2Fobject-oriented-java) course on [Coursera](https://medium.com/u/99c0fb464c1f).\n\nIt’s free to explore and learn but you will be charged if you also want to participate in exercises, assignment, evaluation and need Certification to show in your LinkedIn profile.\n\n### 7\\. Liskov Substitution Principle (LSP)\n\nAccording to the Liskov Substitution Principle, Subtypes must be substitutable for supertype I mean methods or functions which uses superclass type must be able to work with the [object](http://javarevisited.blogspot.com/2012/12/what-is-object-in-java-or-oops-example.html) of subclass without any issue”. \n \nLSP is closely related **to the Single responsibility principle** and **Interface Segregation Principle**.\n\n> If a class has more functionality than subclass might not support some of the functionality and does violate LSP.\n\nIn order to follow [LSP SOLID design principle](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fsolid-principles-object-oriented-design-architecture%2F), derived class or subclass must enhance functionality, but not reduce them. LSP represents “L” on the SOLID acronym.\n\nHere is a code example which violates the Liskov Substitution Principle in Java:\n\n[!(https://cdn-images-1.medium.com/max/1024/1*Gd-makNIG_0XdHvxLiaUFg.jpeg)](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fsolid-principles-object-oriented-design-architecture%2F)\n\nLiskov Substitution Principle in Java\n\nIf you have a method area(Rectangle r) which calculates the area of Rectangle then that code will break when you pass the Square because Square is not really a Rectangle.\n\nIf you are interested in a more real-world example, then the [**SOLID Principles of Object-Oriented Design**](https://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fprinciples-oo-design) course on Pluarlsight is a good course to start with.\n\nBtw, you would need a Pluralsight membership to get access this course, which cost around $29 per month or $299 annually (14% discount). Even if you don’t have a membership, you can still access this course for FREE by taking advantage of their [**10-day free trial**](http://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Flearn) without any commitment, which is a great way to not just access this course for free but also to check the quality of courses before joining Pluralsight\n\n### 8\\. Interface Segregation Principle (ISP)\n\nInterface Segregation Principle stats that, a client should not implement an [interface](http://javarevisited.blogspot.com/2012/04/10-points-on-interface-in-java-with.html) if it doesn’t use that.\n\nThis happens mostly when one interface contains more than one functionality, and the client only needs one functionality and no other. \n \nThere is no doubt that Interface design is a tricky job because once you release your interface you can not change it without breaking all implementation. Well, Java 8’s [default or defender method](https://javarevisited.blogspot.com/2014/07/default-defender-or-extension-method-of-Java8-example-tutorial.html#axzz5kO8vmDxy) feature does provide a way for interface evolution but not all Programming language support that features.\n\n> Another benefit of this design principle in Java is, the interface has the disadvantage of implementing all method before any class can use it so having single functionality means less method to implement.\n\nIf you don’t the get the benefit of the interface in coding then I suggest you read my blog post, the [real usage of an interface in Java](http://www.java67.com/2014/02/what-is-actual-use-of-interface-in-java.html) to learn more.\n\n!(https://cdn-images-1.medium.com/max/400/0*kALM7NtYyY7D40b4.jpg)\n\n### 9\\. Programming for Interface not implementation\n\nA programmer should always _program for the interface and not for implementation_ this will lead to flexible code which can work with any new implementation of the interface. \n \nIn concrete words, you should use interface type on variables, return types of a method or argument type of methods in Java like using SuperClass type to store object rather using SubClass.\n\nI mean\n\nList numbers= getNumbers();\n\ninstead of\n\nArrayList numbers = getNumbers(); \n \nThis has also been advised in many Java books including in [**Effective Java**](https://www.amazon.com/Effective-Java-3rd-Joshua-Bloch/dp/0134685997/?tag=javamysqlanta-20) and [**Head First design pattern**](http://www.amazon.com/dp/0596007124/?tag=javamysqlanta-20) book.\n\nHere is an example of Coding for the interface in Java:\n\n[!(https://cdn-images-1.medium.com/max/1024/1*G7G9QOZgc38o7Bzh9-TCBw.png)](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Frefactoring-to-patterns%2F)\n\nIf you are interested in improving code quality of your program, I also suggest you take a look at the [**Refactoring to Design Patterns**](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Frefactoring-to-patterns%2F) course on Udemy which will help you to improve the internal design with refactoring techniques and design patterns in C#\n\n### 10\\. Delegation principles\n\nDon’t do all stuff by yourself, delegate it to the respective class. Classical example of delegation design principle is [equals() and hashCode() method in Java](http://javarevisited.blogspot.com/2011/02/how-to-write-equals-method-in-java.html).\n\n> In order to compare two objects for equality, we ask the class itself to do comparison instead of Client class doing that check.\n\nThe key benefit of this design principle is **no duplication of code** and pretty easy to modify behavior. Event delegation is another example of this principle, where an event is delegated to handlers for handling.\n\n[!(https://cdn-images-1.medium.com/max/400/0*Yz2uSaYOOI9AsnVK.jpg)](https://medium.com/swlh/5-free-object-oriented-programming-online-courses-for-programmers-156afd0a3a73)\n\n### Summary\n\nAll these **object-oriented design principles** help you write flexible and better code by striving high cohesion and low coupling.\n\nThe theory is the first step, but what is most important is to _develop the ability to find out when to apply these design principles_. \n \nOnce you get hold of that, the next step is to learn Design patterns in Java, which uses these design patterns to solve common problems of application development and software engineering.\n\nIf you are looking for a nice course to start with, I suggest you join the [**From 0 to 1: Design Patterns — 24 That Matter — In Java**](https://click.linksynergy.com/fs-bin/click?id=JVFxdTr9V80&subid=0&offerid=323058.1&type=10&tmpid=14538&RD_PARM1=https%3A%2F%2Fwww.udemy.com%2Ffrom-0-to-1-design-patterns%2F) course on Udemy. It’s very comprehensive and you can get it in just $11 on their several flash sales. \n \nAnyway, here is a nice summary of all these OOP design principles.\n\n!(https://cdn-images-1.medium.com/max/1024/1*MVlQJTdfZ2ou_yA-DrKHTg.png)\n\nFind out, whether we are violating any design principle and compromising the flexibility of code, but again as nothing is perfect in this world, don’t always try to solve the problem with **design patterns and design principle** they are mostly for large enterprise project which has longer maintenance cycle. \n \nBottom line is, professionals programmers should always strive for a highly cohesive and loosely couple solution, code or design. Looking open source code from Apache and Google are some good ways of learning [Java](http://www.java67.com/2018/08/top-10-free-java-courses-for-beginners-experienced-developers.html) and [OOP design principles](https://javarevisited.blogspot.com/2018/07/10-object-oriented-design-principles.html). \n \nThey will show you, how design principles should be used in coding and Java programs. Java Development Kit follows many design principles like [Factory Pattern](http://javarevisited.blogspot.sg/2011/12/factory-design-pattern-java-example.html#axzz51cvxH5kW) in BorderFactory class, [Singleton pattern](https://javarevisited.blogspot.com/2014/05/double-checked-locking-on-singleton-in-java.html) in java.lang.Runtime class, [Decorator pattern](http://www.java67.com/2013/07/decorator-design-pattern-in-java-real-life-example-tutorial.html) on various java.io classes. \n \nIf you are interested in learning object-oriented principles and patterns, then you can look at my another personal favorite [**Head First Object-Oriented Analysis and Design**](http://www.amazon.com/dp/0596008678/?tag=javamysqlanta-20), an excellent book and probably the best material available in object-oriented analysis and design\n\n[!(https://cdn-images-1.medium.com/max/226/0*zcxGVki78MV8h3eE.jpg)](http://www.amazon.com/dp/0596008678/?tag=javamysqlanta-20)\n\nNot many programmers know this book because it is often shadowed by its more popular cousin [Head First Design Pattern](https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124/?tag=javamysqlanta-20) by [Eric Freeman](https://medium.com/u/96a4ff006e35), which is more about how these principles come together to create a pattern you can use directly to solve known problems.\n\n!(https://cdn-images-1.medium.com/max/224/0*50n3hCCWqlc8gkiF)\n\nThese books help a lot to write better code, taking full advantage of various Object-oriented and SOLID design principles. Btw, if you really interested more in Java coding practices then read [**Effective Java 3rd Edition**](https://www.amazon.com/Effective-Java-3rd-Joshua-Bloch/dp/0134685997/?tag=javamysqlanta-20) by Joshua Bloch, a gem by the guy who wrote Java Collection API.\n\nIf you want to learn more about SOLID design Principles, here are some useful resources you can take a look:\n\n1. [Clean Code](http://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882?tag=javamysqlanta-20) By [Robert Martin](https://medium.com/u/ffa32c7b39eb)\n2. [SOLID Principles of Object-Oriented Design](https://pluralsight.pxf.io/c/1193463/424552/7490?u=https%3A%2F%2Fwww.pluralsight.com%2Fcourses%2Fprinciples-oo-design)\n3. [SOLID Principles of Object-Oriented Design and Architecture](https://click.linksynergy.com/deeplink?id=JVFxdTr9V80&mid=39197&murl=https%3A%2F%2Fwww.udemy.com%2Fsolid-principles-object-oriented-design-architecture%2F)\n4. [Refactoring by Martin Fowler](http://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672?tag=javamysqlanta-20)\n\nAnd, if you like this article, you may like these **Java and Programming articles as well**: \n[10 Things Java Programmer should learn in 2019](https://javarevisited.blogspot.com/2017/12/10-things-java-programmers-should-learn.html#axzz5atl0BngO) \n[10 Books Every Programmer Must Read](http://www.java67.com/2015/03/10-books-every-programmer-and-software-engineer-read.html) \n[10 Tips to Improve Your Programming skill](http://javarevisited.blogspot.sg/2014/01/10-tips-to-improve-programming-skill-become-better-programmer.html#axzz553pz1hYh) \n[10 Tools Every Software Developer should know](http://javarevisited.blogspot.sg/2018/01/10-tools-every-software-developer-know.html#axzz559dyoLSA) \n[5 Courses to Learn Software Architecture in Depth](https://javarevisited.blogspot.com/2019/03/5-courses-programmers-can-join-to-learn.html#axzz5jKqbGRcg) \n[20 Libraries and APIS Java Programmer Should Know](https://javarevisited.blogspot.com/2018/01/top-20-libraries-and-apis-for-java-programmers.html) \n[Top 10 Programming languages to Learn in 2019](http://www.java67.com/2017/12/10-programming-languages-to-learn-in.html) \n[10 Framework and Library Java and Web Developer Should Learn](http://javarevisited.blogspot.sg/2018/01/10-frameworks-java-and-web-developers-should-learn.html) \n \nThanks for reading this article. If you find these object-oriented design principles useful then please share with your friends and colleagues. If you have any questions or feedback then please drop a note.\n\nBtw, if you buy any of my recommended book or course, I’ll be also be paid.\n\nIf you like this article then please consider following me on medium ([javinpaul](https://medium.com/u/bb36d8439904)). if you’d like to be notified for every new post and don’t forget to follow [**javarevisited**](https://twitter.com/javarevisited) on Twitter!\n\n> **P. S. —** If you are really passionate about your Coding and want to improve your coding skill there are no better books then **Clean Code** by [Robert Martin](https://medium.com/u/ffa32c7b39eb) and Refactoring by [Martin P. Fowler](https://medium.com/u/8cc65672c5d). Just go and read them.