Please enable JavaScript.

Coggle requires JavaScript to display documents.

Design Pattern - Coggle Diagram

Design Pattern

Creational design pattern

Singleton

Example

public class Singleton {
    // Step 1: Create a private static variable to hold the single instance of the class
    private static Singleton instance;

    // Step 2: Make the constructor private so it cannot be instantiated outside
    private Singleton() {
        // private constructor to prevent instantiation
    }

    // Step 3: Provide a public static method to get the instance of the class
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton(); // Create instance only if it doesn't exist
        }
        return instance;  // Return the single instance
    }
}

public class DoubleCheckLockingSingleton {

    private static volatile DoubleCheckLockingSingleton instance;

    private DoubleCheckLockingSingleton() {
    }

    public static DoubleCheckLockingSingleton getInstance() {
        // Do something before get instance ...
        if (instance == null) {
            // Do the task too long before create instance ...
            // Block so other threads cannot come into while initialize
            synchronized (DoubleCheckLockingSingleton.class) {
                // Re-check again. Maybe another thread has initialized before
                if (instance == null) {
                    instance = new DoubleCheckLockingSingleton();
                }
            }
        }
        // Do something after get instance ...
        return instance;
    }
}

Prototype

Example

public class Computer implements Cloneable {
    private String os;

    public Computer(String os) {
        super();
        this.os = os;
    }

    @Override
    protected Computer clone() {
        try {
            return (Computer) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return null;
    }
 }

Factory method

Example

public enum BankType {

    TPBANK, ...;

}

public class BankFactory {

    private BankFactory() {
    }

    public static final Bank createBank(BankType bankType) {
        switch (bankType) {

        case TPBANK:
            return new TPBank();

        ....

        default:
            throw new IllegalArgumentException("This bank type is unsupported");
        }
    }

}

public class Client {

    public static void main(String[] args) {
        Bank bank = BankFactory.createBank(BankType.TPBANK);
    }
}

Builder

Example

public class Home {
    public Home() {
    }

    public Home(String address) {
        this.address = address;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    private String address;
}

public class HomeBuilder {
    private Home home;

    public HomeBuilder() {
        home = new Home();
    }

    public HomeBuilder address(String address) {
        home.setAddress(address);
        return this;
    }

    public Home build() {
        return home;
    }
}

public class Client {

    public static void main(String[] args) {
        Home home = new HomeBuilder().address("Ha Noi").build();
    }
}