In Factory pattern, we create object without exposing the creation logic to the client and refer to newly created object using a common interface.

The main goal of the Factory Pattern is to define an interface for creating an object, but leave the choice of its type to the subclasses, creating the object without specifying its exact class. This pattern promotes loose coupling between the client code and the specific classes being instantiated.

The Prototype Pattern is a creational design pattern that allows the creation of new objects by copying an existing object, known as the prototype

Design Patterns (sourcemaking.com)

Creational design patterns

These design patterns are all about class instantiation. This pattern can be further divided into class-creation patterns and object-creational patterns. While class-creation patterns use inheritance effectively in the instantiation process, object-creation patterns use delegation effectively to get the job done.

· Abstract Factory
Creates an instance of several families of classes

· Builder
Separates object construction from its representation

· Factory Method
Creates an instance of several derived classes

· Object Pool
Avoid expensive acquisition and release of resources by recycling objects that are no longer in use

· Prototype
A fully initialized instance to be copied or cloned

· Singleton
A class of which only a single instance can exist

Structural design patterns

These design patterns are all about Class and Object composition. Structural class-creation patterns use inheritance to compose interfaces. Structural object-patterns define ways to compose objects to obtain new functionality.

· Adapter
Match interfaces of different classes

· Bridge
Separates an object’s interface from its implementation

· Composite
A tree structure of simple and composite objects

· Decorator
Add responsibilities to objects dynamically

· Facade
A single class that represents an entire subsystem

· Flyweight
A fine-grained instance used for efficient sharing

·

Private Class Data
Restricts accessor/mutator access

· Proxy
An object representing another object

Behavioral design patterns

These design patterns are all about Class's objects communication. Behavioral patterns are those patterns that are most specifically concerned with communication between objects.

· Chain of responsibility
A way of passing a request between a chain of objects

· Command
Encapsulate a command request as an object

· Interpreter
A way to include language elements in a program

· Iterator
Sequentially access the elements of a collection

· Mediator
Defines simplified communication between classes

· Memento
Capture and restore an object's internal state

· Null Object
Designed to act as a default value of an object

· Observer
A way of notifying change to a number of classes

·

State
Alter an object's behavior when its state changes

· Strategy
Encapsulates an algorithm inside a class

· Template method
Defer the exact steps of an algorithm to a subclass

· Visitor
Defines a new operation to a class without change

Builder

Bridge Design Pattern - GeeksforGeeks

Bridge pattern decouple an abstraction from its implementation so that the two can vary independently.

Without Bridge Design Pattern 

With Bridge Design Pattern

// Java code to demonstrate

// bridge design pattern

// abstraction in bridge pattern

abstract class Vehicle {

protected Workshop workShop1;

protected Workshop workShop2;

protected Vehicle(Workshop workShop1, Workshop workShop2)

    {

this.workShop1 = workShop1;

this.workShop2 = workShop2;

    }

abstract public void manufacture();

}

// Refine abstraction 1 in bridge pattern

class Car extends Vehicle {

public Car(Workshop workShop1, Workshop workShop2)

    {

super(workShop1, workShop2);

    }

    @Override

public void manufacture()

    {

        System.out.print("Car ");

        workShop1.work();

        workShop2.work();

    }

}

// Refine abstraction 2 in bridge pattern

class Bike extends Vehicle {

public Bike(Workshop workShop1, Workshop workShop2)

    {

super(workShop1, workShop2);

    }

    @Override

public void manufacture()

    {

        System.out.print("Bike ");

        workShop1.work();

        workShop2.work();

    }

}

// Implementer for bridge pattern

interface Workshop

{

abstract public void work();

}

// Concrete implementation 1 for bridge pattern

class Produce implements Workshop {

    @Override

public void work()

    {

        System.out.print("Produced");

    }

}

// Concrete implementation 2 for bridge pattern

class Assemble implements Workshop {

    @Override

public void work()

    {

        System.out.print(" And");

        System.out.println(" Assembled.");

    }

}

// Demonstration of bridge design pattern

class BridgePattern {

public static void main(String[] args)

    {

        Vehicle vehicle1 = new Car(new Produce(), new Assemble());

        vehicle1.manufacture();

        Vehicle vehicle2 = new Bike(new Produce(), new Assemble());

        vehicle2.manufacture();

    }

Output : 

Car Produced And Assembled.

Bike Produced And Assembled.