There are mainly three types of design patterns:

Encapsulation is one of the fundamental concepts in object-oriented programming (OOP). It describes the idea of bundling data and methods that work on that data within one unit, e.g., a class in Java. This concept is also often used to hide the internal representation, or state, of an object from the outside.

Bypassing encapsulation with Typecast and Pointers (Totally illegal way) First of all, it is worth to mention that using pointers and typecasting this way is a bad practice. This method may or may not provide the wanted data. By default, all class variables and methods are private .

• Creational. These design patterns are all about class instantiation or object creation.
• Structural. These design patterns are about organizing different classes and objects to form larger structures and provide new functionality.
• Behavioral.

When object-oriented programming was introduced, inheritance was the main pattern used to extend object functionality. Today, inheritance is often considered a design smell. This pattern is designed in a way that multiple decorators can be stacked on top of each other, each adding new functionality.

Structural Design Patterns:Generally deal with relationships between entities, making it easier for these entities to work together. Behavioral Design Patterns:Used in communications between entities and make it easier and more flexible for these entities to communicate.

As verbs the difference between structure and pattern is that structure is to give structure to; to arrange while pattern is to apply a pattern.

In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships among entities. Retrofit Interface Pattern: An adapter used as a new interface for multiple classes at the same time.

Usage

• A system should be independent of how its objects and products are created.
• A set of related objects is designed to be used together.
• Hiding the implementations of a class library or product, revealing only their interfaces.
• Constructing different representation of independent complex objects.

The main difference between them is that the Builder pattern primarily describes the creation of complex objects step by step. In the Abstract Factory pattern, the emphasis is on families of objects-products. Builder returns the product in the last step.

There are following 6 types of creational design patterns.

• Factory Method Pattern.
• Abstract Factory Pattern.
• Singleton Pattern.
• Prototype Pattern.
• Builder Pattern.
• Object Pool Pattern.

The stated purpose of the Factory Patterns is: Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

The Factory Method design pattern is used by first defining a separate operation, a factory method, for creating an object, and then using this factory method by calling it to create the object. This enables writing of subclasses that decide how a parent object is created and what type of objects the parent contains.

Factory and Dependency injection both are the design pattern which can be used to enhance loose coupling abilities between the software components. Factory design pattern is used to create objects. It is used to create objects. …

How to Implement

1. Add a private static field to the class for storing the singleton instance.
2. Declare a public static creation method for getting the singleton instance.
3. Implement “lazy initialization” inside the static method.
4. Make the constructor of the class private.

Factory design pattern is used to create objects or Class in Java and it provides loose coupling and high cohesion. Factory pattern encapsulate object creation logic which makes it easy to change it later when you change how object gets created or you can even introduce new object with just change in one class.

Using factories instead of constructors or prototypes allows one to use polymorphism for object creation, not only object use.

Serialization is used to convert an object of byte stream and save in a file or send over a network. Suppose you serialize an object of a singleton class. Then if you de-serialize that object it will create a new instance and hence break the singleton pattern.

1. import java.lang.reflect.Constructor;
2. public class ReflectionSingletonDemo {
3. public static void main(String[] args) {
4. ReflectionSingleton instanceTwo = null ;
5. // Below code will change constructor access level from private to public.
6. constructor.setAccessible( true );
7. // Creating second instance.
8. } catch (Exception e) {

In serialization, we can save the object of a byte stream into a file or send over a network. Suppose if you serialize the Singleton class, and then again de-serialize that object, it will create a new instance, hence deserialization will break the Singleton pattern.

Thread Safe Singleton: A thread safe singleton in created so that singleton property is maintained even in multithreaded environment. To make a singleton class thread-safe, getInstance() method is made synchronized so that multiple threads can’t access it simultaneously. Pros: It is also thread safe.