Few of the familiar Design Patterns in Java

1. Interface 
Objects define their interaction with the outside world through the methods that they expose. These methods form the object's interface with the outside world, for example, the buttons on the front of your television set, are the interface between you and the encapsulated electrical television components. 

An interface pattern encapsulates a coherent set of services and attributes, without explicitly binding the functionality to a particular object or a code. In Java an interface is a programming construct, similar to an abstract class, that allows you to specify zero or more method signatures without providing the implementations of those methods.

Implementing an interface allows a class to become more formal about the behavior it promises to provide. Interfaces form a contract between the class and the outside world, and this contract is enforced at build time by the compiler. If your class claims to implement an interface, all methods defined by that interface must appear in its source code before the class will successfully compile.

2. Abstract
Abstract pattern can be used to create an abstract class which misses definitions for one or more methods. Thus it restricts the creation of an object of that class. You must first create a subclass and provide definitions for the abstract methods. Unlike interfaces, abstract classes may implement some of the methods. Though you can't instantiate an abstract class, you can invoke its static methods. Abstract classes form an interesting and useful middle ground between interfaces and classes.  

3. Delegation
The Delegation and Interface patterns are often used together. Delegation is used to avoid Inheritance. Delegation is a way of extending and reusing a class by writing another class with additional functionality that uses instances of the original class to provide the original functionality.        

4. Marker Interface
The Marker Interface pattern uses interfaces declaring no methods or variables to indicate semantic attributes of a class. It works particularly well with utility classes that determine something about objects without assuming that they are an instance of any particular class.

5. Immutable
The Immutable pattern reduces the overhead of concurrent access to an object and increases the robustness of objects that share references to the same object. It accomplishes this by not allowing an object’s state information to change after it is constructed. The Immutable pattern also avoids the need to synchronize multiple threads of execution that share an object.

6. Single Threaded Execution
The Single Threaded Execution pattern is the pattern most frequently used to coordinate access by multiple threads to a shared object. The Immutable object pattern can be used to avoid the need for the Single Threaded Execution pattern or any other kind of access coordination.

7. Proxy
The Proxy pattern forces method calls to an object to occur indirectly through a proxy object that acts as a surrogate for the other object, delegating method calls to that object. Classes for proxy objects are declared in a way that usually eliminates client object’s awareness that they are dealing with a proxy. Proxy is a very general pattern that occurs in many other patterns, but never by itself in its pure form.