Design Pattern is a description or template for how to write a code that can be used in many different situations and improves code readability for coders and architects familiar with the patterns.
Creational design patterns abstract the instantiation process. They help make a system independent of how its objects are created, composed, and represented. A class creational pattern uses inheritance to vary the class thats instantiated, whereas an object creational pattern will delegate instantiation to another object. The creational design patterns allow configuring of a software system as a system with product objects that vary widely in structure and functionality. Such configuration can be static, i.e., specified at compile-time, or dynamic, i.e., specified at run-time. For Example : Factory Design Pattern #### Singleton Pattern #### Factory Pattern #### Abstract Factory Pattern #### Builder Pattern #### Prototype Pattern
Structural patterns are concerned with how classes and objects are composed to form larger structures. Structural class patterns use inheritance to compose interfaces or implementations. For example, multiple inheritance can be seen as a kind of structural design patterns, since it uses inheritance to mix two or more classes into a new one. Rather than composing interfaces or implementations, structural object patterns describe ways to compose objects to realize new functionality. The added flexibility of object composition comes from the ability to change the composition at run-time, which is impossible with static class composition. For Example : Facade Method
Behavioural patterns are concerned with algorithms and the assignment of responsibility between objects. Behavioural patterns describe not just patterns of objects or classes but also the patterns of communication between them. These patterns characterize complex control flow that is difficult to follow at run-time. They shift your focus away from flow of control to let you concentrate just on the way objects are interconnected. Behavioural class patterns use inheritance to distribute behaviour between classes. Behavioural object patterns use object composition rather than inheritance. For example, a behavioural object pattern can describe how a group of object might cooperate to perform a task that no single object can carry out by itself. A typical example is the Observer pattern from the Smalltalk (Model/View/Controller paradigm). Views are used to show the state of data (contained in Model) and they are observers of this data. Whenever a model changes its state all views are notified and they can update the representation of the data in views. For Example : Startegy Design Pattern, Mediator Design Pattern
To change gradle default location in eclipse, window -> Preference -> gradle -> gradle user home -> browse the folder