Java Design Patterns

1. Singleton Pattern: A singleton is a class that ensures only one instance of itself exists in the Java virtual machine. The purpose of the singleton pattern is to ensure that a class has only one instance while providing a global access point to this instance. Example: A singleton class that manages a database connection.

2. Factory Pattern: The Factory pattern is a creational pattern that provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. Example: An abstract factory class that creates different types of vehicles such as cars, trucks, and motorcycles.

3. Abstract Factory Pattern: The Abstract Factory pattern provides a way to encapsulate a group of individual factories that have a common theme without specifying their concrete classes. Example: An abstract factory that creates different types of GUI widgets such as buttons, text fields, and labels.

4. Builder Pattern: The Builder pattern separates the construction of a complex object from its representation, allowing the same construction process to create various representations. Example: A builder class that creates different types of sandwiches with different ingredients.

5. Prototype Pattern: The Prototype pattern is used to create a duplicate of an existing object rather than creating a new instance from scratch. Example: A prototype class that creates duplicate objects of different shapes such as circles, squares, and triangles.

6. Adapter Pattern: The Adapter pattern is used to provide a link between two incompatible objects by wrapping the original object with a new adapter object. Example: An adapter class that provides compatibility between a square socket and a round plug.

7. Decorator Pattern: The Decorator pattern is used to add additional behavior to an existing object dynamically. Example: A decorator class that adds different toppings to a pizza.

8. Facade Pattern: The Facade pattern provides a simplified interface to a complex system of objects. Example: A facade class that provides a simplified interface to a complex banking system.

9. Observer Pattern: The Observer pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. Example: An observer class that notifies registered users about stock market updates.

These are some of the most commonly used Java Design Patterns, and there are many more to explore. The key to using design patterns effectively is to understand the problem they are trying to solve, and to choose the right pattern for the specific problem you are trying to solve.