Prototype Design Pattern Overview

Shallow Copy and Deep Copy in Prototype Design Pattern

• Shallow copy references the same underlying data as the original object.
• Modifying the shallow copy affects the original object because they share the same memory location.

Introduction to Creational Patterns

• Singleton Pattern: Ensures a class has only one instance and provides a global point of access.
• Factory Method Pattern: Defines an interface for creating an object, but lets subclasses decide which class to instantiate.
• Abstract Factory Pattern: Provides an interface for creating families of related or dependent objects without specifying their concrete classes.
• Builder Pattern: Separates the construction of a complex object from its representation so that the same construction process can create different representations.
• Prototype Pattern: Specifies the kind of object to create using a prototypical instance, and creates new objects by copying this prototype.

Prototype Design Pattern

• The Prototype Design Pattern is a creational design pattern that allows objects to be created by cloning an existing object, rather than creating a new object from scratch.
• This pattern can improve performance, reduce object creation time, and simplify the creation of complex objects.
• The Prototype Design Pattern is commonly used in scenarios where you need to create objects with complex configurations, such as in game development, image processing, and configuration management systems.

Understanding Shallow Copy

• Shallow copy creates a new object that references the same underlying data as the original object.
• Changes made to the shallow copy will affect the original object.

Deep Copy

• Deep copy creates a duplicate of an object with all its properties and values independently copied.
• Changes made to the deep copy will not affect the original object.

Explanation of Shallow Copy Example

• The example demonstrates a "Person" class with an "Address" class.
• Both original and shallow copy of the "Person" object share the same "Address" object in memory.
• Modifying the Address in either copy affects both.

Explanation of Deep Copy Example

• Shows the "Person" with a "Address" object.
• Deep copy creates a separate "Address" object to avoid any changes in the original object when modifying a copied object.

Explanation of Results

• Shallow copying shares references to reference type members, like Address.
• Changing one affects both copies in the case of shared references,
• Value type members like Name are independent.

Choosing the Right Copy Mechanism

• Shallow copy: Faster, but changes in a copy affect the original.
• Deep copy: Slower but creates an independent copy, changes in a copy do not affect original.
• Consider the object type and memory constraints.

Real-world Applications

• Duplicating files in file systems
• Copying data in databases
• Cloning virtual machines
• Duplicating game levels

Factory Design Pattern

• The Factory Design Pattern provides an interface for creating objects in a superclass but allows subclasses to alter the type of object being created.
• Examples include payment methods (like credit card, PayPal, Google Pay) and animal creation in a game .
• This design pattern enables flexibility and extensibility by letting subclasses handle the creation process for specific types of payment methods or animals.

Explore the concepts of Shallow and Deep Copy within the Prototype Design Pattern, as well as an introduction to various Creational Patterns like Singleton, Factory Method, and Builder. Understand how these patterns help in creating flexible and reusable object-oriented software.