{"id":19849106,"url":"https://github.com/edsonwade/design-patterns-creational","last_synced_at":"2026-05-09T23:12:10.202Z","repository":{"id":252396686,"uuid":"840000268","full_name":"edsonwade/design-patterns-creational","owner":"edsonwade","description":"Design Pattern Creational","archived":false,"fork":false,"pushed_at":"2024-08-16T15:49:41.000Z","size":25975,"stargazers_count":0,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-01-11T12:48:12.945Z","etag":null,"topics":["abstract-factory-pattern","builder-pattern","creational-patterns","design-patterns","factory-method-pattern","prototype-pattern","singleton-pattern"],"latest_commit_sha":null,"homepage":"","language":"Java","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/edsonwade.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-08-08T18:54:52.000Z","updated_at":"2024-08-16T15:49:45.000Z","dependencies_parsed_at":"2024-11-12T13:20:23.946Z","dependency_job_id":"108d1d0a-d58e-422a-b2b3-fe71c3eb9cd6","html_url":"https://github.com/edsonwade/design-patterns-creational","commit_stats":null,"previous_names":["edsonwade/design-patterns-creational"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edsonwade%2Fdesign-patterns-creational","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edsonwade%2Fdesign-patterns-creational/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edsonwade%2Fdesign-patterns-creational/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/edsonwade%2Fdesign-patterns-creational/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/edsonwade","download_url":"https://codeload.github.com/edsonwade/design-patterns-creational/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":241226842,"owners_count":19930488,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["abstract-factory-pattern","builder-pattern","creational-patterns","design-patterns","factory-method-pattern","prototype-pattern","singleton-pattern"],"created_at":"2024-11-12T13:19:21.918Z","updated_at":"2026-05-09T23:12:10.163Z","avatar_url":"https://github.com/edsonwade.png","language":"Java","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Creational Design Patterns\n\n## Singleton Pattern\n\nThe Singleton Pattern ensures that a class has only one instance and provides a global point of access to that instance.\nThis is useful when exactly one object is needed to coordinate actions across the system.\n\n### Example\n\n```java\npublic class Singleton {\n    private static Singleton instance;\n\n    private Singleton() {}\n\n    public static Singleton getInstance() {\n        if (instance == null) {\n            instance = new Singleton();\n        }\n        return instance;\n    }\n\n    public void showMessage() {\n        System.out.println(\"Hello from Singleton!\");\n    }\n}\n// Usage\npublic class Main {\n    public static void main(String[] args) {\n        Singleton singleton = Singleton.getInstance();\n        singleton.showMessage();\n    }\n}\n```\n## Builder Pattern\n\nThe Builder Pattern is used to construct a complex object step by step.\nIt separates the construction of a complex object from its representation,\nallowing the same construction process to create different representations.\n\n### Example\n\n```java\n// Product class\npublic class House {\n    private String foundation;\n    private String structure;\n    private String roof;\n    private String interior;\n\n    public void setFoundation(String foundation) { this.foundation = foundation; }\n    public void setStructure(String structure) { this.structure = structure; }\n    public void setRoof(String roof) { this.roof = roof; }\n    public void setInterior(String interior) { this.interior = interior; }\n\n    @Override\n    public String toString() {\n        return \"House [foundation=\" + foundation + \", structure=\" + structure + \", roof=\" + roof + \", interior=\" + interior + \"]\";\n    }\n}\n\n// Builder interface\npublic interface HouseBuilder {\n    void buildFoundation();\n    void buildStructure();\n    void buildRoof();\n    void buildInterior();\n    House getHouse();\n}\n\n// Concrete Builder\npublic class ConcreteHouseBuilder implements HouseBuilder {\n    private House house;\n\n    public ConcreteHouseBuilder() {\n        this.house = new House();\n    }\n\n    @Override\n    public void buildFoundation() {\n        house.setFoundation(\"Concrete Foundation\");\n    }\n\n    @Override\n    public void buildStructure() {\n        house.setStructure(\"Concrete Structure\");\n    }\n\n    @Override\n    public void buildRoof() {\n        house.setRoof(\"Concrete Roof\");\n    }\n\n    @Override\n    public void buildInterior() {\n        house.setInterior(\"Modern Interior\");\n    }\n\n    @Override\n    public House getHouse() {\n        return this.house;\n    }\n}\n\n// Director\npublic class Director {\n    private HouseBuilder houseBuilder;\n\n    public Director(HouseBuilder houseBuilder) {\n        this.houseBuilder = houseBuilder;\n    }\n\n    public House constructHouse() {\n        houseBuilder.buildFoundation();\n        houseBuilder.buildStructure();\n        houseBuilder.buildRoof();\n        houseBuilder.buildInterior();\n        return houseBuilder.getHouse();\n    }\n}\n//Usage\npublic class Main {\n    public static void main(String[] args) {\n        HouseBuilder builder = new ConcreteHouseBuilder();\n        Director director = new Director(builder);\n        House house = director.constructHouse();\n        System.out.println(house);\n    }\n}\n```\n## Factory Method Pattern\nThe Factory Method Pattern provides an interface for creating objects in a superclass\nbut allows subclasses to alter the type of objects that will be created.\n\n### Example\n\n```java\n// Abstract Product\npublic interface Product {\n    void use();\n}\n\n// Concrete Products\npublic class ConcreteProductA implements Product {\n    @Override\n    public void use() {\n        System.out.println(\"Using ConcreteProductA\");\n    }\n}\n\npublic class ConcreteProductB implements Product {\n    @Override\n    public void use() {\n        System.out.println(\"Using ConcreteProductB\");\n    }\n}\n\n// Creator (Abstract Factory)\npublic abstract class Creator {\n    public abstract Product factoryMethod();\n\n    public void someOperation() {\n        Product product = factoryMethod();\n        product.use();\n    }\n}\n\n// Concrete Creators\npublic class ConcreteCreatorA extends Creator {\n    @Override\n    public Product factoryMethod() {\n        return new ConcreteProductA();\n    }\n}\n\npublic class ConcreteCreatorB extends Creator {\n    @Override\n    public Product factoryMethod() {\n        return new ConcreteProductB();\n    }\n}\n\n// Usage\npublic class Main {\n    public static void main(String[] args) {\n        Creator creatorA = new ConcreteCreatorA();\n        creatorA.someOperation(); // Output: Using ConcreteProductA\n\n        Creator creatorB = new ConcreteCreatorB();\n        creatorB.someOperation(); // Output: Using ConcreteProductB\n    }\n}\n```\n\n## Prototype Pattern\nThe Prototype Pattern is a creational design pattern that allows you to create new objects by copying existing objects,\nknown as prototypes.\n\n### Example\n\n```java\npublic abstract class Item implements Cloneable {\n    private String title;\n    private double price;\n    private String url;\n\n    @Override\n    protected Object clone() throws CloneNotSupportedException {\n        return super.clone();\n    }\n}\n\npublic class Movie extends Item {\n    private String runtime;\n\n    public String getRuntime() {\n        return runtime;\n    }\n\n    public void setRuntime(String runtime) {\n        this.runtime = runtime;\n    }\n}\n\npublic class Book extends Item {\n    private int numberOfPages;\n\n    public int getNumberOfPages() {\n        return numberOfPages;\n    }\n\n    public void setNumberOfPages(int numberOfPages) {\n        this.numberOfPages = numberOfPages;\n    }\n}\n\npublic class Registry {\n    private Map\u003cString, Item\u003e items = new HashMap\u003c\u003e();\n\n    public Registry() {\n        loadItems();\n    }\n\n    public Item createItem(String type) {\n        Item item = null;\n        try {\n            item = (Item) items.get(type).clone();\n        } catch (CloneNotSupportedException e) {\n            throw new RuntimeException(e);\n        }\n        return item;\n    }\n\n    private void loadItems() {\n        Movie movie = new Movie();\n        movie.setTitle(\"Basic Movie\");\n        movie.setPrice(10.0);\n        movie.setRuntime(\"2 hours\");\n        items.put(\"Movie\", movie);\n\n        Book book = new Book();\n        book.setNumberOfPages(335);\n        book.setPrice(19.99);\n        book.setTitle(\"Harry Potter and the Philosopher's Stone\");\n        items.put(\"Book\", book);\n    }\n}\n\n//Usage\npublic class Main {\n    public static void main(String[] args) {\n        Registry registry = new Registry();\n        Item clonedMovie = registry.createItem(\"Movie\");\n        Item clonedBook = registry.createItem(\"Book\");\n    }\n}\n```\n\n## Abstract Factory Pattern\nThe Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.\n\n```java\n// Abstract Products\npublic interface Button {\n    void paint();\n}\n\npublic interface Checkbox {\n    void paint();\n}\n\n// Concrete Products\npublic class WindowsButton implements Button {\n    @Override\n    public void paint() {\n        System.out.println(\"Rendering a button in a Windows style.\");\n    }\n}\n\npublic class MacButton implements Button {\n    @Override\n    public void paint() {\n        System.out.println(\"Rendering a button in a Mac style.\");\n    }\n}\n\npublic class WindowsCheckbox implements Checkbox {\n    @Override\n    public void paint() {\n        System.out.println(\"Rendering a checkbox in a Windows style.\");\n    }\n}\n\npublic class MacCheckbox implements Checkbox {\n    @Override\n    public void paint() {\n        System.out.println(\"Rendering a checkbox in a Mac style.\");\n    }\n}\n\n// Abstract Factory\npublic interface GUIFactory {\n    Button createButton();\n    Checkbox createCheckbox();\n}\n\n// Concrete Factories\npublic class WindowsFactory implements GUIFactory {\n    @Override\n    public Button createButton() {\n        return new WindowsButton();\n    }\n\n    @Override\n    public Checkbox createCheckbox() {\n        return new WindowsCheckbox();\n    }\n}\n\npublic class MacFactory implements GUIFactory {\n    @Override\n    public Button createButton() {\n        return new MacButton();\n    }\n\n    @Override\n    public Checkbox createCheckbox() {\n        return new MacCheckbox();\n    }\n}\n\n// Client\npublic class Application {\n    private Button button;\n    private Checkbox checkbox;\n\n    public Application(GUIFactory factory) {\n        button = factory.createButton();\n        checkbox = factory.createCheckbox();\n    }\n\n    public void paint() {\n        button.paint();\n        checkbox.paint();\n    }\n}\n\n//Usage\npublic class Main {\n    private static Application configureApplication() {\n        Application app;\n        GUIFactory factory;\n        String osName = System.getProperty(\"os.name\").toLowerCase();\n        if (osName.contains(\"win\")) {\n            factory = new WindowsFactory();\n        } else {\n            factory = new MacFactory();\n        }\n        app = new Application(factory);\n        return app;\n    }\n\n    public static void main(String[] args) {\n        Application app = configureApplication();\n        app.paint();\n    }\n}\n```\n\n\n### Diagrams of each Design type Creational Pattern\n\n### Singleton Pattern\n```mermaid\nclassDiagram\n    class Singleton {\n        -instance: Singleton\n        +getInstance(): Singleton\n        +showMessage(): void\n    }\n```\n### Builder Pattern\n```mermaid\nclassDiagram\n    class Director {\n        -builder: HouseBuilder\n        +constructHouse(): House\n    }\n    class House {\n        -foundation: String\n        -structure: String\n        -roof: String\n        -interior: String\n    }\n    class HouseBuilder {\n        +buildFoundation(): void\n        +buildStructure(): void\n        +buildRoof(): void\n        +buildInterior(): void\n        +getHouse(): House\n    }\n    class ConcreteHouseBuilder {\n        -house: House\n        +buildFoundation(): void\n        +buildStructure(): void\n        +buildRoof(): void\n        +buildInterior(): void\n        +getHouse(): House\n    }\n    Director --\u003e HouseBuilder\n    HouseBuilder \u003c|-- ConcreteHouseBuilder\n    ConcreteHouseBuilder --\u003e House\n```\n\n### Factory Method Patter\n```mermaid\nclassDiagram\n    class Creator {\n        +factoryMethod(): Product\n        +someOperation(): void\n    }\n    class Product {\n        +use(): void\n    }\n    class ConcreteCreatorA {\n        +factoryMethod(): Product\n    }\n    class ConcreteCreatorB {\n        +factoryMethod(): Product\n    }\n    class ConcreteProductA {\n        +use(): void\n    }\n    class ConcreteProductB {\n        +use(): void\n    }\n    Creator \u003c|-- ConcreteCreatorA\n    Creator \u003c|-- ConcreteCreatorB\n    Product \u003c|-- ConcreteProductA\n    Product \u003c|-- ConcreteProductB\n    ConcreteCreatorA --\u003e ConcreteProductA\n    ConcreteCreatorB --\u003e ConcreteProductB\n```\n### Prototype Pattern\n```mermaid\nclassDiagram\n    class Registry {\n        -items: Map\u003cString, Item\u003e\n        +createItem(type: String): Item\n        +loadItems(): void\n    }\n    class Item {\n        -title: String\n        -price: double\n        -url: String\n        +clone(): Object\n    }\n    class Movie {\n        -runtime: String\n        +getRuntime(): String\n        +setRuntime(runtime: String): void\n    }\n    class Book {\n        -numberOfPages: int\n        +getNumberOfPages(): int\n        +setNumberOfPages(pages: int): void\n    }\n    Registry --\u003e Item\n    Item \u003c|-- Movie\n    Item \u003c|-- Book\n```\n### Abstract Factory Pattern\n```mermaid\nclassDiagram\n    class GUIFactory {\n        +createButton(): Button\n        +createCheckbox(): Checkbox\n    }\n    class Button {\n        +paint(): void\n    }\n    class Checkbox {\n        +paint(): void\n    }\n    class WindowsFactory {\n        +createButton(): Button\n        +createCheckbox(): Checkbox\n    }\n    class MacFactory {\n        +createButton(): Button\n        +createCheckbox(): Checkbox\n    }\n    class WindowsButton {\n        +paint(): void\n    }\n    class MacButton {\n        +paint(): void\n    }\n    class WindowsCheckbox {\n        +paint(): void\n    }\n    class MacCheckbox {\n        +paint(): void\n    }\n    GUIFactory \u003c|-- WindowsFactory\n    GUIFactory \u003c|-- MacFactory\n    Button \u003c|-- WindowsButton\n    Button \u003c|-- MacButton\n    Checkbox \u003c|-- WindowsCheckbox\n    Checkbox \u003c|-- MacCheckbox\n    WindowsFactory --\u003e WindowsButton\n    WindowsFactory --\u003e WindowsCheckbox\n    MacFactory --\u003e MacButton\n    MacFactory --\u003e MacCheckbox\n```\n\n\n## Summary\n\n-**Singleton Pattern**: Ensures a class has only one instance and provides a global point of access to it.\n\n-**Builder Pattern**: Separates the construction of a complex object from its representation.\n\n-**Factory Method Pattern**: Provides an interface for creating objects in a superclass but allows subclasses to \nalter the type of objects that will be created.\n\n-**Prototype Pattern**: Allows you to create new objects by copying existing objects, known as prototypes.\n\n-**Abstract Factory Pattern**: Provides an interface for creating families of related or dependent objects without \nspecifying their concrete classes.","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fedsonwade%2Fdesign-patterns-creational","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fedsonwade%2Fdesign-patterns-creational","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fedsonwade%2Fdesign-patterns-creational/lists"}