Java @ Desk

Facade is design pattern in java that helps to re design a poorly structured API into a well defined API. It provides a simpler interface to the client, but internally it interacts with complex components and get a job done for the client. It hides a complexity behind exposing a simpler interface to the client.

Consider a scenario, of an Employee Hiring consultancy that collects all the information of an employee going to join in some company. The information includes personal details, last employment details, last drawn salay, expected salary, desired location.
Now, lets say, there are different complex interfaces, one that returns employee personal information, one give employee past experience details and so on.
So, in this case, if a client need a complete list of information of one particular employe, there needs to give a call to lots of other interface.

Proxy, as the name suggest, does the work what the real one should do. Proxy is some thing that performs the task what the real java object must perform to do.Typically, one instance of the complex object and multiple proxy objects are created, all of which contain a reference to the single original complex object. Any operations performed on the proxies are forwarded to the original object. Once all instances of the proxy are out of scope, the complex object's memory may be deallocated.

Why to use proxy?
There can be many instances, where real object wants the task to be performed by the proxy object. In this case, proxy first checks if the real instance object is available or not. It not create the new instance but if the object is already available, do not create the new instance, proxy instance will be used to perform the operation.

As the name suggest, it decorates some basic behaviour of an object. It is used to extend the behaviour of certain object. In implementing the decorator pattern you construct a wrapper around an object by extending its behavior. The wrapper will do its job before or after and delegate the call to the wrapped instance.

Use decorator pattern, to add responsibility to objects without affecting other objects.

The Adapter pattern is used so that two unrelated interfaces can work together. The joining between them is called an Adapter. This is something like we convert interface of one class into interface expected by the client. We do that using an Adapter.

There is a SalaryCalculator.java class file which takes employeeId and annualPackage fields as input and returns the monthly inhand for that employee.

Prototype pattern is used where the application needs many instances of an same object with minimal changes. Hence the Cloneable interface is used in this where the clone of the object is returned.

Question arises why clone, why not new object creation if many instances are required?

In general, cloning or creating an object using new operator are same. But there are cases where new object creation would be heavy in cases where a constructor for an object does some heavy provessing. Say for example, creating a database connection. In this case, cloning would be much much cheaper.

This design pattern breaks the complex object creation into simpler processes. The construction process remains the same to create different representations. Director controls the construction of the object and only the director knows what type of object to create.

This pattern helps the object creation in a step by step manner. It breaks the module into smaller pieces and the smaller pieces in integration gives the complex object.

In factory design pattern, there is a factory java class that hides the object creation from outside world. In this pattern, the object creation depends on the data passed as an argument to the factory class and the factory class decides based on the argument passed, object of which class needs to be instantiated and returned.

This pattern provides abstraction or interface implementation and the factory class generally creates an object of subclass and returns the same.

Consider a simple scenario of IT industry where employees from IT team gets a variable payout every year where other departments like HR or Admin does not get.

What are design patterns?

Answer: Design pattern is a strategy to use to build up a web application. It helps in designing of an application that will be more flexibility, easy to maintain, etc. Design Patterns also solve specific programming challenges regarding usability and maintainability.

In some other cases, the pattern is also a way to deal with "inefficiencies" of the language, where "inefficiency" is very broad in its meaning, and not always in a bad term.

Issues with basic version of Singleton pattern design:
1) It could happen that SingletonPattern.getSingletonPatternObject() call may occur from 2 different places in an application at the same time and 2 objects get created which will violate the principal of the pattern

2) Consider the code
SingletonPattern clonedSingletonPattern = (SingletonPattern) obj.clone();
This code will create the copy of the singleton object which again violates the design patters implementation

Click Singleton Pattern Java With Double Locking and Without Cloning for complete version of Singleton Design Pattern

To avoid above issues here is an improved version

public class SingletonPattern {

    // Make the constructor private so that it cannot be instantiated outside the class
    private SingletonPattern() {

    }

    // Variable for SingletonPattern class
    private static SingletonPattern singletonPattern;

    // Method to get the instance of SingletonPattern class
    public static synchronized SingletonPattern getSingletonPatternObject() {
        if (singletonPattern == null) {
            singletonPattern = new SingletonPattern();
        }
        return singletonPattern;
    }

    public Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException("Thrown this exception in order to avoid the creation of copy of this object");
    }
}

As the name suggests, Singleton patters allows only single instance of particular class throughout the application.

Why to create a Singleton class in an application?

Answer: Say for instance, an application wants to load a property class which contains a set of properties, and this property file is being used throughout the application. So a better way is to load that property file once and use it throughout.