devkuma – Design Pattern

Concepts and Types of Design Patterns

kc@example.com (kc kim) — Tue, 08 Mar 2022 08:52:00 +0900

What Is a Design Pattern?

A design pattern is an excellent reusable solution for recurring chronic problems that often appear in specific contexts when designing software.
“Don’t reinvent the wheel” means that there is no need to recreate from scratch something that has already been made and works well.

What Is a Pattern?

- Even when developing different software modules or various application software systems with different features, common design problems exist among them, and there are also commonalities among the solutions that handle those problems. These similarities are called patterns. - Patterns create a common language and play a very important role in making communication between team members smoother.

Types of Design Patterns

Known design patterns are divided into 23 patterns as follows. Broadly, they are classified into three types: Creational, Structural, and Behavioral. These are called GoF(Gang of Four) design patterns and were devised by four well-known developers: Erich Gamma, Richard Helm, Ralph Johnson, and John Vissides. These four developers organized “experience” and “internal accumulation” in the form of design patterns. They are called the Gang of Four, or GoF.

Creational Pattern

Creational patterns are related to object creation. They encapsulate object creation and composition, providing flexibility so that even if a specific object is created or changed, the overall program structure is not greatly affected.

Abstract Factory Methods: create products by assembling related parts.
Factory Methods: delegate instance creation to subclasses.
Builder: assemble complex instances.
Prototype: create instances by copying.
Singleton: only one instance.

Structural Pattern

Structural patterns create larger structures by combining classes or objects. For example, they can wrap two objects with different interfaces to provide a single interface, or combine objects to provide new functionality.

Adapter: reuse by wrapping with one layer.
Bridge: separate the hierarchy of features from the hierarchy of implementation.
Composite: treat containers and contents uniformly.
Decorator: treat decorations and contents uniformly.
Facade: provide a simple entry point.
Flyweight: eliminate waste by sharing identical objects.
Proxy: create it when it becomes necessary.

Behavioral Pattern

Behavioral patterns are related to algorithms and responsibility distribution between objects or classes. They focus on how to divide work that one object cannot perform alone among several objects while minimizing coupling between those objects.

Chain of Responsibility: pass responsibility along.
Command: turn a request into a class.
Interpreter: express grammar rules as classes.
Iterator: count one by one.
Mediator: communicate through a single counselor.
Memento: preserve state.
Observer: notify changes in state.
State: express state as a class.
Strategy: replace the whole algorithm.
Template Methods: delegate concrete processing to subclasses.
Visitor: move through a structure and perform work.

Java Example Source

Java言語で學ぶデザインパタ-ン入門

References

Design Pattern | Abstract Factory Methods

kc@example.com (kc kim) — Thu, 17 Mar 2022 15:26:00 +0900

What Is the Abstract Factory Pattern?

Abstract Factory means an abstract factory.
Being abstract means focusing only on the interface without considering how it is concretely implemented.
The Abstract Factory pattern focuses on interfaces rather than the concrete implementation of parts. It assembles parts using only those interfaces and organizes them into products.
It creates products by combining related parts.
In GoF design patterns, it is classified as a creational design pattern.

Abstract Factory Pattern Example Program

This example program outputs a favorites list in HTML format.

Class Diagram

1. Factory Class

This class represents an abstract factory. It creates Link, Tray, and Page.

Factory.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Factory {

    public abstract Link createLink(String caption, String url);

    public abstract Tray createTray(String caption);

    public abstract Page createPage(String title);

    public static Factory getFactory(String classname) {
        Factory factory = null;
        try {
            factory = (Factory) Class.forName(classname).getDeclaredConstructor().newInstance();
        } catch (ClassNotFoundException e) {
            System.err.println("클래스 " + classname + "를 찾을 수 없습니다.");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return factory;
    }
}

2. Item Class

This class treats Link and Tray uniformly.

Item.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Item {
    protected String caption;

    public Item(String caption) {
        this.caption = caption;
    }

    public abstract String makeHTML();
}

3. Link Class

Abstract part: a class that represents an HTML link.

Link.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

public abstract class Link extends Item {
    protected String url;

    public Link(String caption, String url) {
        super(caption);
        this.url = url;
    }
}

4. Tray Class

Abstract part: a class that collects Link and Tray.

Tray.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

import java.util.ArrayList;

public abstract class Tray extends Item {
    protected ArrayList tray = new ArrayList();

    public Tray(String caption) {
        super(caption);
    }

    public void add(Item item) {
        tray.add(item);
    }
}

5. Page Class

Abstract part: a class that represents an HTML page.

Page.java

package com.devkuma.designpattern.creational.abstractfactory.factory;

import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.ArrayList;

public abstract class Page {
    protected String title;
    protected ArrayList content = new ArrayList();

    public Page(String title) {
        this.title = title;
    }

    public void add(Item item) {
        content.add(item);
    }

    public void output() {
        try {
            String filename = title + ".html";
            Writer writer = new FileWriter(filename);
            writer.write(this.makeHTML());
            writer.close();
            System.out.println(filename + "을 생성했습니다.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public abstract String makeHTML();
}

6. ListFactory Class

This class represents a concrete factory. It creates ListLink, ListTray, and ListPage.

ListFactory.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Factory;
import com.devkuma.designpattern.creational.abstractfactory.factory.Link;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

public class ListFactory extends Factory {
    public Link createLink(String caption, String url) {
        return new ListLink(caption, url);
    }

    public Tray createTray(String caption) {
        return new ListTray(caption);
    }

    public Page createPage(String title) {
        return new ListPage(title);
    }
}

7. ListLink Class

Concrete part: a class that represents an HTML link.

ListLink.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Link;

public class ListLink extends Link {
    public ListLink(String caption, String url) {
        super(caption, url);
    }

    public String makeHTML() {
        return "  <li><a href=\"" + url + "\">" + caption + "</a></li>\n";
    }
}

8. ListTray Class

Concrete part: a class that collects Link and Tray.

ListTray.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Item;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

import java.util.Iterator;

public class ListTray extends Tray {
    public ListTray(String caption) {
        super(caption);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<li>\n");
        buffer.append(caption + "\n");
        buffer.append("<ul>\n");
        Iterator it = tray.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</li>\n");
        return buffer.toString();
    }
}

9. ListPage Class

Concrete part: a class that represents an HTML page.

ListPage.java

package com.devkuma.designpattern.creational.abstractfactory.listfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Item;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;

import java.util.Iterator;

public class ListPage extends Page {
    public ListPage(String title) {
        super(title);
    }

    public String makeHTML() {
        StringBuffer buffer = new StringBuffer();
        buffer.append("<html><head><title>" + title + "</title></head>\n");
        buffer.append("<body>\n");
        buffer.append("<h1>" + title + "</h1>\n");
        buffer.append("<ul>\n");
        Iterator it = content.iterator();
        while (it.hasNext()) {
            Item item = (Item) it.next();
            buffer.append(item.makeHTML());
        }
        buffer.append("</ul>\n");
        buffer.append("</body></html>\n");
        return buffer.toString();
    }
}

10. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.creational.abstractfactory;

import com.devkuma.designpattern.creational.abstractfactory.factory.Factory;
import com.devkuma.designpattern.creational.abstractfactory.factory.Link;
import com.devkuma.designpattern.creational.abstractfactory.factory.Page;
import com.devkuma.designpattern.creational.abstractfactory.factory.Tray;

public class Main {
    public static void main(String[] args) {

        Factory factory = Factory.getFactory("com.devkuma.designpattern.creational.abstractfactory.listfactory.ListFactory");

        Link devkuma = factory.createLink("Devkuma", "https://www.devkuma.com//");
        Link araikuma = factory.createLink("araikuma", "https://araikuma.tistory.com/");

        Link naver = factory.createLink("Naver", "https://www.naver.com/");
        Link daum = factory.createLink("Daum", "https://www.daum.com/");
        Link google = factory.createLink("Google", "https://www.google.com/");

        Tray pgTray = factory.createTray("프로그래밍");
        pgTray.add(devkuma);
        pgTray.add(araikuma);

        Tray searchTray = factory.createTray("검색사이트");
        searchTray.add(naver);
        searchTray.add(daum);
        searchTray.add(google);

        Page page = factory.createPage("즐겨찾기");
        page.add(pgTray);
        page.add(searchTray);
        page.output();
    }
}

11. Execution Result

The file generated by the program is shown below.

즐겨찾기.html

<html><head><title>즐겨찾기</title></head>
<body>
<h1>즐겨찾기</h1>
<ul>
<li>
프로그래밍
<ul>
  <li><a href="https://www.devkuma.com//">Devkuma</a></li>
  <li><a href="https://araikuma.tistory.com/">araikuma</a></li>
</ul>
</li>
<li>
검색사이트
<ul>
  <li><a href="https://www.naver.com/">Naver</a></li>
  <li><a href="https://www.daum.com/">Daum</a></li>
  <li><a href="https://www.google.com/">Google</a></li>
</ul>
</li>
</ul>
</body></html>

Advantages of the Abstract Factory Pattern

For example, when adding a new concrete factory to the example program, you create subclasses of Factory, Link, Tray, and Page and implement each abstract method.
In other words, you only concretize the abstract parts held by the classes in the factory package. At this time, no matter how many concrete factories are added, there is no need to modify the abstract factory.

Design Pattern | Builder Pattern

kc@example.com (kc kim) — Mon, 14 Mar 2022 00:25:00 +0900

What Is the Builder Pattern?

The word build means to build something large with structure.
When creating something with a complex structure, it is difficult to complete it all at once. First, each part that makes up the whole is created, and then it is assembled step by step.
The same construction process can create different representation objects.
Whether there are many or few parameters for the constructor, parameters are accepted one after another, and after all parameters are received, they are integrated and used at once.
The Builder pattern is a way to build instances that have structure.
In GoF design patterns, it is classified as a creational design pattern.

Builder Pattern Example Program

This example program outputs a document in plain text and HTML formats.

Class Diagram

1. Builder Class

This abstract class defines methods for composing a document.

Builder.java

public abstract class Builder {
    public abstract void makeTitle(String title);
    public abstract void makeString(String str);
    public abstract void makeItems(String[] items);
    public abstract void close();
}

2. Guide Class

This class creates one document.

Guide.java

package com.devkuma.designpattern.creational.builder;

public class Guide {

    private Builder builder;

    public Guide(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.makeTitle("야유회에 대해서");
        builder.makeString("일시");
        builder.makeItems(new String[]{
                "2022/3/14 (월)",
                "11:00~",
        });
        builder.makeString("장소");
        builder.makeItems(new String[]{
                "xxx 캠핌장",
        });
        builder.makeString("준비물");
        builder.makeItems(new String[]{
                "회비",
                "고기",
                "음료수",
        });
        builder.close();
    }
}

3. TextBuilder Class

This class creates a document as plain text.

TextBuilder.java

package com.devkuma.designpattern.creational.builder;

public class TextBuilder extends Builder {

    private StringBuffer buffer = new StringBuffer();

    public void makeTitle(String title) {
        buffer.append("==============================\n");
        buffer.append("'" + title + "'\n");
        buffer.append("\n");
    }

    public void makeString(String str) {
        buffer.append("- " + str + "\n");
    }

    public void makeItems(String[] items) {
        for (int i = 0; i < items.length; i++) {
            buffer.append("　- " + items[i] + "\n");
        }
        buffer.append("\n");
    }

    public void close() {
        buffer.append("==============================\n");
    }

    public String getResult() {
        return buffer.toString();
    }
}

4. HTMLBuilder Class

This class creates a document as an HTML file.

HTMLBuilder.java

package com.devkuma.designpattern.creational.builder;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class HtmlBuilder extends Builder {

    private String filename;
    private PrintWriter writer;

    public void makeTitle(String title) {
        filename = title + ".html";
        try {
            writer = new PrintWriter(new FileWriter(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
        writer.println("<html><head><title>" + title + "</title></head><body>");
        writer.println("<h1>" + title + "</h1>");
    }

    public void makeString(String str) {
        writer.println("<p>" + str + "</p>");
    }

    public void makeItems(String[] items) {
        writer.println("<ul>");
        for (int i = 0; i < items.length; i++) {
            writer.println("<li>" + items[i] + "</li>");
        }
        writer.println("</ul>");
    }

    public void close() {
        writer.println("</body></html>");
        writer.close();
    }

    public String getResult() {
        return filename;
    }
}

5. Main Class

This is the main class that runs the example program.

Main.java

package com.devkuma.designpattern.creational.builder;

public class Main {
    public static void main(String[] args) {

        if (args.length != 1) {
            System.exit(0);
        }
        if (args[0].equals("plain")) {
            TextBuilder textbuilder = new TextBuilder();
            Guide guide = new Guide(textbuilder);
            guide.construct();
            String result = textbuilder.getResult();
            System.out.println(result);
        } else if (args[0].equals("html")) {
            HtmlBuilder htmlbuilder = new HtmlBuilder();
            Guide guide = new Guide(htmlbuilder);
            guide.construct();
            String filename = htmlbuilder.getResult();
            System.out.println(filename + "이 작성되었습니다.");
        } else {
            System.exit(0);
        }
    }
}

6. Execution Result

Text

==============================
'야유회에 대해서'

- 일시
　- 2022/3/14 (월)
　- 11:00~

- 장소
　- xxx 캠핌장

- 준비물
　- 회비
　- 고기
　- 음료수

==============================

HTML

<html><head><title>야유회에 대해서</title></head><body>
<h1>야유회에 대해서</h1>
<p>일시</p>
<ul>
<li>2022/3/14 (월)</li>
<li>11:00~</li>
</ul>
<p>장소</p>
<ul>
<li>xxx 캠핌장</li>
</ul>
<p>준비물</p>
<ul>
<li>회비</li>
<li>고기</li>
<li>음료수</li>
</ul>
</body></html>

7. Advantages of the Builder Pattern

In the example program, the Main class does not know how to build the document, that is, the methods of the Builder class. The Main class can build the document simply by calling the construct method of the Guide class.
The Guide class uses the Builder class to create the document, but it does not know which class it is actually using, whether TextBuilder or HtmlBuilder.
An instance of TextBuilder or an instance of HTMLBuilder can both be passed to Guide and still work correctly because the Guide class does not know the concrete class of the Builder class.
Because it does not know the concrete class, replacement is possible, and because replacement is possible, its value as a component increases.

Design Pattern | Factory Method

kc@example.com (kc kim) — Sun, 13 Mar 2022 17:56:00 +0900

What Is the Factory Method Pattern?

The English word factory means a place that produces things. In a factory, products are made to match specifications, and when requirements change slightly, slightly different products are also produced.
The Factory Method pattern creates an instance that matches the desired specification.
The Factory Method pattern defines the way to create instances in the superclass, while concrete creation processing is performed by subclasses.
The Factory Method pattern is a factory for creating instances structured with the Template Method pattern.
In GoF design patterns, it is classified as a creational design pattern.

Factory Method Pattern Example Program

This program creates ID cards in an ID card factory.

Class Diagram

1. Product Class

This is the base class for objects created by the Factory.

Product.java

package com.devkuma.designpattern.creational.factorymethod.framwork;

public abstract class Product {
    public abstract void use();
}

2. Factory Class

This is the base class of the Factory. It creates instances.

Factory.java

package com.devkuma.designpattern.creational.factorymethod.framwork;

public abstract class Factory {

    public final Product create(String owner) {
        Product product = createProduct(owner);
        registerProduct(product);
        return product;
    }

    protected abstract Product createProduct(String owner);
    protected abstract void registerProduct(Product product);
}

3. IDCard Class

This is a concrete class that implements the methods defined by the Product class.

IDCard.java

package com.devkuma.designpattern.creational.factorymethod.idcard;

import com.devkuma.designpattern.creational.factorymethod.framwork.Product;

public class IdCard extends Product {

    private String owner;

    IdCard(String owner) {
        System.out.println(owner + "의 카드를 만듭니다.");
        this.owner = owner;
    }

    public void use() {
        System.out.println(owner + "의 카드를 사용합니다.");
    }

    public String getOwner() {
        return owner;
    }
}

4. IDCardFactory Class

This is a concrete class that implements the methods defined by the Factory class.

IDCardFactory.java

package com.devkuma.designpattern.creational.factorymethod.idcard;

import com.devkuma.designpattern.creational.factorymethod.framwork.Factory;
import com.devkuma.designpattern.creational.factorymethod.framwork.Product;

import java.util.ArrayList;

public class IdCardFactory extends Factory {

    private ArrayList<String> owners = new ArrayList();

    protected Product createProduct(String owner) {
        return new IdCard(owner);
    }

    protected void registerProduct(Product product) {
        IdCard icCard = (IdCard) product;
        String owner = icCard.getOwner();
        owners.add(owner);
    }

    public ArrayList<String> getOwners() {
        return owners;
    }
}

5. Main Class

This is the main class that executes the main processing.

Main.java

package com.devkuma.designpattern.creational.factorymethod;

import com.devkuma.designpattern.creational.factorymethod.framwork.Factory;
import com.devkuma.designpattern.creational.factorymethod.framwork.Product;
import com.devkuma.designpattern.creational.factorymethod.idcard.IdCardFactory;

public class Main {
    public static void main(String[] args) {
        Factory factory = new IdCardFactory();
        Product card1 = factory.create("devkuma");
        Product card2 = factory.create("kimkc");
        Product card3 = factory.create("yunho");
        card1.use();
        card2.use();
        card3.use();
    }
}

6. Execution Result

devkuma의 카드를 만듭니다.
kimkc의 카드를 만듭니다.
yunho의 카드를 만듭니다.
devkuma의 카드를 사용합니다.
kimkc의 카드를 사용합니다.
yunho의 카드를 사용합니다.

Advantages of the Factory Method Pattern

Factory/Product exist in the framework package, while IDCardFactory/IDCard exist in the idcard package.
The framework package does not import the idcard package. In other words, the framework package does not depend on the idcard package.
When creating completely different products and factories, there is no need to modify the contents of the framework package.

Design Pattern | Prototype Pattern

kc@example.com (kc kim) — Mon, 14 Mar 2022 01:24:00 +0900

What Is the Prototype Pattern?

The English word prototype means an original form or model.
The Prototype pattern does not create an instance from a class using new Xxx(). Instead, it creates another instance from an existing instance. In other words, it creates an instance by copying.
The work of making a copy is called clone.
In GoF design patterns, it is classified as a creational design pattern.

Prototype Pattern Example Program

This example program underlines or surrounds an input string.

Class Diagram

1. Product Interface

This interface defines the cloning method. It extends Java’s Cloneable interface.

Product.java

package com.devkuma.designpattern.creational.prototype.framework;

import java.lang.Cloneable;

public interface Product extends Cloneable {
    void use(String s);

    Product createClone();
}

2. Manager Class

This class instructs and manages the creation of Products.

Manager.java

package com.devkuma.designpattern.creational.prototype.framework;

import java.util.HashMap;

public class Manager {

    private HashMap showcase = new HashMap();

    public void register(String name, Product prototype) {
        showcase.put(name, prototype);
    }

    public Product create(String prototypeName) {
        Product p = (Product) showcase.get(prototypeName);
        return p.createClone();
    }
}

3. UnderlinePen Class

This class implements the Product interface. It is a class that “underlines text.”

UnderlinePen.java

package com.devkuma.designpattern.creational.prototype.product;

import com.devkuma.designpattern.creational.prototype.framework.Product;

public class UnderlinePen implements Product {

    private char underlineChar;

    public UnderlinePen(char underlineChar) {
        this.underlineChar = underlineChar;
    }

    public void use(String s) {

        int length = s.getBytes().length;

        System.out.println(s);

        for (int i = 0; i < length; i++) {
            System.out.print(underlineChar);
        }

        System.out.println();
    }

    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            // Exception thrown when the object's class does not implement the Cloneable interface.
            e.printStackTrace();
        }
        return p;
    }
}

4. MessageBox Class

This class implements the Product interface. It is a class that “surrounds text.”

MessageBox.java

package com.devkuma.designpattern.creational.prototype.product;

import com.devkuma.designpattern.creational.prototype.framework.Product;

public class MessageBox implements Product {

    private char decoChar;

    public MessageBox(char decoChar) {
        this.decoChar = decoChar;
    }

    public void use(String s) {

        int length = s.getBytes().length;

        for (int i = 0; i < length + 2; i++) {
            System.out.print(decoChar);
        }

        System.out.println();
        System.out.println(decoChar + s + decoChar);

        for (int i = 0; i < length + 2; i++) {
            System.out.print(decoChar);
        }

        System.out.println();
    }

    public Product createClone() {
        Product p = null;
        try {
            p = (Product) clone();
        } catch (CloneNotSupportedException e) {
            // Exception thrown when the object's class does not implement the Cloneable interface.
            e.printStackTrace();
        }
        return p;
    }
}

5. Main Class

This is the main class that executes the main processing.

Main.java

package com.devkuma.designpattern.creational.prototype;

import com.devkuma.designpattern.creational.prototype.framework.Manager;
import com.devkuma.designpattern.creational.prototype.framework.Product;
import com.devkuma.designpattern.creational.prototype.product.MessageBox;
import com.devkuma.designpattern.creational.prototype.product.UnderlinePen;

public class Main {
    public static void main(String[] args) {

        Manager manager = new Manager();
        UnderlinePen upen = new UnderlinePen('~');
        MessageBox mbox = new MessageBox('*');
        MessageBox pbox = new MessageBox('+');
        manager.register("strong message", upen);
        manager.register("warning box", mbox);
        manager.register("slash box", pbox);

        Product p1 = manager.create("strong message");
        p1.use("Hello world");
        System.out.println();
        Product p2 = manager.create("warning box");
        p2.use("Hello world");
        System.out.println();
        Product p3 = manager.create("slash box");
        p3.use("Hello world");
    }
}

6. Execution Result

Hello world
~~~~~~~~~~~

*************
*Hello world*
*************

+++++++++++++
+Hello world+
+++++++++++++

Advantages of the Prototype Pattern

The example program is relatively simple, but creating an instance may require complex processing or time-consuming processing. Creating an instance with new Xxx() every time can be very inefficient.
By creating a prototype and copying it, instances can be created easily.

Design Pattern | Singleton Pattern

kc@example.com (kc kim) — Thu, 13 May 2021 09:10:45 +0900

What Is the Singleton Pattern?

Singleton means a set that has only one element.
The Singleton pattern guarantees that only one instance exists.
The Singleton pattern is used when you want an instance to be created only once in a program.
It is a pattern that creates only one object without using global variables and allows the created object to be referenced from anywhere.
Configuration values used globally in a program also need the Singleton pattern to create only one object and share information.
Examples include classes that represent system settings or window systems.
In GoF design patterns, it is classified as a creational design pattern.

Singleton Pattern Example Program

This program creates a singleton instance.

Class Diagram

1. Singleton Class

This class returns the unique instance.
The constructor of the Singleton class is specified as private. This prevents the constructor from being called outside the Singleton class.

Singleton.java

package com.devkuma.designpattern.creational.singleton.ex1;

public class Singleton {

    private static Singleton singleton = new Singleton();

    private Singleton() {
        System.out.println("인스턴스를 생성하였습니다.");
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

2. Main Class

This is the main class that executes the main processing.

Main.java

package com.devkuma.designpattern.creational.singleton.ex1;

public class Main {
    public static void main(String[] args) {
        Singleton obj1 = Singleton.getInstance();
        Singleton obj2 = Singleton.getInstance();
        if (obj1 == obj2) {
            System.out.println("obj1와 obj2는 동일한 인스턴스입니다.");
        } else {
            System.out.println("obj1와 obj2는 동일한 인스턴스가 아닙니다.");
        }
    }
}

3. Execution Result

인스턴스를 생성하였습니다.
obj1와 obj2는 동일한 인스턴스입니다.

Advantages of the Singleton Pattern

The Singleton pattern places a limit on the number of instances.
If multiple instances exist, they can affect each other and create unexpected bugs.
However, if there is a guarantee that only one instance exists, programming can be done based on that precondition.

Singleton Pattern Using synchronized

Example Program for Singleton Pattern Using synchronized

Because multiple objects can access it at the same time, declaring synchronized makes it thread-safe.

package com.devkuma.designpattern.creational.singleton.ex2;

public class SynchronizedSingleton1 {

    private static Singleton1 instance;

    /**
     * Inaccessible constructor
     */
    private SynchronizedSingleton1() {
    }

    public static synchronized Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }

    public static void main(String[] args) {

        Singleton1 singleton1 = Singleton1.getInstance();
        Singleton1 singleton2 = Singleton1.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

Example Program for a Singleton Pattern with Improved synchronized Performance

Because synchronization can cause performance issues, the code below improves performance by synchronizing only once at first.

volatile: a keyword that guarantees a variable works correctly at once in a threading environment.

package com.devkuma.designpattern.creational.singleton.ex2;

public class SynchronizedSingleton2 {

    private volatile static Singleton2 instance;

    /**
     * Inaccessible constructor
     */
    private SynchronizedSingleton2() {
    }

    public static Singleton2 getInstance() {
        if (instance == null) {
            // The instance is created only once at first.
            synchronized (Singleton2.class) {
                if (instance == null) {
                    instance = new Singleton2();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {

        Singleton2 singleton1 = Singleton2.getInstance();
        Singleton2 singleton2 = Singleton2.getInstance();

        System.out.println(singleton1);
        System.out.println(singleton2);
    }
}

Design Pattern | Adapter Pattern

kc@example.com (kc kim) — Sun, 13 Mar 2022 17:56:00 +0900

What Is the Adapter Pattern?

The English word adapter means something that adapts.
The Adapter pattern is a method for converting something already provided into the required form when it cannot be used as-is. In other words, it is a way to change an interface.
Think of an adapter plug that connects in the middle when the voltage does not match.
In the pattern, if there are two incompatible interfaces on both sides, you create a bridge that connects them.
There are methods using inheritance and methods using delegation.
- Adapter Pattern by class
  - An Adapter Pattern that uses inheritance.
- Adapter Pattern by instance
  - An Adapter Pattern that uses delegation.
It is also called the Wrapper pattern. Wrapper means something that wraps.
In GoF design patterns, it is classified as a structural design pattern.

Adapter Pattern Example Program

This example program displays a student’s name and age.

1. Method Using Class Inheritance

Class Diagram

1-1. Human Class

This is the originally provided class.

Human.java

package com.devkuma.designpattern.structural.adapter.ex1;

public class Human {

    private String name;
    private int age;

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printName() {
        System.out.println(name);
    }

    public void printAge() {
        System.out.println(age);
    }
}

1-2. Student Interface

This is the required interface.

Student.java

package com.devkuma.designpattern.structural.adapter.ex1;

public interface Student {
    void showName();

    void showAge();
}

1-3. HumanAdapter Class

This class plays the Adapter role.

HumanAdapter.java

package com.devkuma.designpattern.structural.adapter.ex1;

public class HumanAdapter extends Human implements Student {

    public HumanAdapter(String name, int age) {
        super(name, age);
    }

    public void showName() {
        printName();
    }

    public void showAge() {
        printAge();
    }
}

1-4. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.adapter.ex1;

public class Main {
    public static void main(String[] args) {
        Student student = new HumanAdapter("devkuma", 25);
        student.showName();
        student.showAge();
    }
}

1-5. Execution Result

devkuma
25

2. Method Using Delegation

2-1. Human Class

This is the originally provided class.

Human.java

package com.devkuma.designpattern.structural.adapter.ex2;

public class Human {

    private String name;
    private int age;

    public Human(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printName() {
        System.out.println(name);
    }

    public void printAge() {
        System.out.println(age);
    }
}

2-2. Student Interface

This is the required interface.

Student.java

package com.devkuma.designpattern.structural.adapter.ex2;

public interface Student {
    void showName();

    void showAge();
}

2-3. HumanAdapter Class

This class plays the Adapter role.

HumanAdapter.java

package com.devkuma.designpattern.structural.adapter.ex2;

public class HumanAdapter implements Student {

    private Human human;

    public HumanAdapter(String name, int age) {
        this.human = new Human("田中", 25);;
    }

    public void showName() {
        human.printName();
    }

    public void showAge() {
        human.printAge();
    }
}

2-4. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.adapter.ex2;

public class Main {
    public static void main(String[] args) {
        Student student = new HumanAdapter("devkuma", 25);
        student.showName();
        student.showAge();
    }
}

2-5. Execution Result

devkuma
25

Advantages of the Adapter Pattern

The Adapter pattern wraps an existing class and creates the class that is needed. Using this pattern, you can quickly create a required group of methods.
Even if a bug is detected, if the existing class has been tested sufficiently, you can focus on investigating the Adapter class, making program checking easier.
Also, because the Adapter pattern can implement functionality without modifying the existing class, it reduces the effort of retesting the existing class.

Design Pattern | Bridge Pattern

kc@example.com (kc kim) — Thu, 17 Mar 2022 14:30:00 +0900

What Is the Bridge Pattern?

The English word bridge means a bridge.
Just as a real-world bridge connects both sides of a river, the Bridge pattern connects two places.
It separates implementation from abstraction. It is a pattern that places a bridge between the feature class hierarchy and the implementation class hierarchy.
The two places crossed by the Bridge pattern are the feature class hierarchy and the implementation class hierarchy.
- Feature class hierarchy: a hierarchy where the superclass has basic features and subclasses add new features.
- Implementation class hierarchy: a hierarchy where the superclass defines the interface through abstract methods and subclasses implement that interface through concrete methods.
In GoF design patterns, it is classified as a structural design pattern.

Bridge Pattern Example Program

This example program displays an input string a specified number of times and a random number of times.

Class Diagram

1. Display Class

This is the class that performs “display” and belongs to the feature class hierarchy. The impl field held by this class becomes the “bridge” between the two class hierarchies.

Display.java

package com.devkuma.designpattern.structural.bridge;

public class Display {

    private DisplayImpl impl;

    public Display(DisplayImpl impl) {
        this.impl = impl;
    }

    public void open() {
        impl.rawOpen();
    }

    public void print() {
        impl.rawPrint();
    }

    public void close() {
        impl.rawClose();
    }

    public final void display() {
        open();
        print();
        close();
    }
}

2. CountDisplay Class

This class belongs to the feature class hierarchy and adds the feature “display a specified number of times.”

CountDisplay.java

package com.devkuma.designpattern.structural.bridge;

public class CountDisplay extends Display {

    public CountDisplay(DisplayImpl impl) {
        super(impl);
    }

    public void multiDisplay(int times) {
        open();
        for (int i = 0; i < times; i++) {
            print();
        }
        close();
    }
}

3. RandomCountDisplay Class

This class belongs to the feature class hierarchy and adds the feature “display a random number of times.”

RandomCountDisplay.java

package com.devkuma.designpattern.structural.bridge;

import java.util.Random;

public class RandomCountDisplay extends CountDisplay {

    private Random random = new Random();

    public RandomCountDisplay(DisplayImpl impl) {
        super(impl);
    }

    public void randomDisplay(int times) {
        multiDisplay(random.nextInt(times));
    }
}

4. DisplayImpl Class

This class defines methods for “display” and belongs to the implementation class hierarchy.

DisplayImpl.java

public abstract class DisplayImpl {
    public abstract void rawOpen();
    public abstract void rawPrint();
    public abstract void rawClose();
}

5. StringDisplayImpl Class

This class belongs to the implementation class hierarchy and displays using a string.

StringDisplayImpl.java

package com.devkuma.designpattern.structural.bridge;

public class StringDisplayImpl extends DisplayImpl {

    private String string;
    private int width;

    public StringDisplayImpl(String string) {
        this.string = string;
        this.width = string.getBytes().length;
    }

    public void rawOpen() {
        printLine();
    }

    public void rawPrint() {
        System.out.println("|" + string + "|");
    }

    public void rawClose() {
        printLine();
    }

    private void printLine() {
        System.out.print("+");
        for (int i = 0; i < width; i++) {
            System.out.print("-");
        }
        System.out.println("+");
    }
}

6. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.bridge;

public class Main {

    public static void main(String[] args) {
        Display display = new Display(new StringDisplayImpl("Display Test"));
        CountDisplay countDisplay = new CountDisplay(new StringDisplayImpl("CountDisplay Test"));
        RandomCountDisplay randomCountDisplay = new RandomCountDisplay(new StringDisplayImpl("RandomCountDisplay Test"));
        display.display();
        countDisplay.multiDisplay(5);
        randomCountDisplay.randomDisplay(10);
    }
}

7. Execution Result

+------------+
|Display Test|
+------------+
+-----------------+
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
|CountDisplay Test|
+-----------------+
+-----------------------+
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
|RandomCountDisplay Test|
+-----------------------+

Advantages

As mentioned earlier, the characteristic of the Bridge pattern is that it separates the feature class hierarchy and the implementation class hierarchy. If these two class hierarchies are separated, each class hierarchy can be extended independently.
To add a feature, add a class to the feature class hierarchy. At this time, the implementation class hierarchy does not need to be modified at all. Moreover, the added feature becomes available to all implementations.
In the example program, adding the CountDisplay class or RandomCountDisplay class corresponds to adding features.
In this way, the Bridge pattern makes class extension easier to anticipate and manage.

Design Pattern | Composite Pattern

kc@example.com (kc kim) — Thu, 17 Mar 2022 15:05:00 +0900

What Is the Composite Pattern?

The word composite means mixed or compound.
The Composite pattern creates a recursive structure by treating containers and contents uniformly.
To treat directories and files together as directory entries, it can be useful to treat containers and contents as the same kind of thing. For example, a container may contain contents, and it may also contain another container. In this way, a recursive structure can be created.
In GoF design patterns, it is classified as a structural design pattern.

Composite Pattern Example Program

This example program displays a list of directories and files.

Class Diagram

1. Entry Class

This is the base class for File and Directory.

Entry.java

package com.devkuma.designpattern.structural.composite;

public abstract class Entry {

    public abstract String getName();

    protected abstract void printList(String prefix);

    public void printList() {
        printList("");
    }
}

2. File Class

This class represents a file.

File.java

package com.devkuma.designpattern.structural.composite;

public class File extends Entry {

    private String name;

    public File(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    protected void printList(String prefix) {
        System.out.println(prefix + "/" + name);
    }
}

3. Directory Class

This class represents a directory.

Directory.java

package com.devkuma.designpattern.structural.composite;

import java.util.ArrayList;
import java.util.Iterator;

public class Directory extends Entry {

    private String name;
    private ArrayList<Entry> directory = new ArrayList();

    public Directory(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    public Entry add(Entry entry) {
        directory.add(entry);
        return this;
    }

    @Override
    protected void printList(String prefix) {
        System.out.println(prefix + "/" + name);
        Iterator<Entry> it = directory.iterator();
        while (it.hasNext()) {
            Entry entry = it.next();
            entry.printList(prefix + "/" + name);
        }
    }
}

4. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.composite;

public class Main {
    public static void main(String[] args) {

        Directory workspaceDir = new Directory("workspace");
        Directory compositeDir = new Directory("composite");
        Directory testDir1 = new Directory("test1");
        Directory testDir2 = new Directory("test2");
        workspaceDir.add(compositeDir);
        workspaceDir.add(testDir1);
        workspaceDir.add(testDir2);

        File directory = new File("Directory.java");
        File entity = new File("Entity.java");
        File file = new File("file.java");
        File main = new File("main.java");
        compositeDir.add(directory);
        compositeDir.add(entity);
        compositeDir.add(file);
        compositeDir.add(main);
        workspaceDir.printList();
    }
}

5. Execution Result

/workspace
/workspace/composite
/workspace/composite/Directory.java
/workspace/composite/Entity.java
/workspace/composite/file.java
/workspace/composite/main.java
/workspace/test1
/workspace/test2

Advantages

Because all objects(File and Directory) share a common abstract class, the client does not need to be aware of whether something is a File or a Directory and can treat them uniformly.
Also, even if a new class such as SymbolicLink is added, client processing is not affected as long as the interface of the base class(Entry) does not change.

Design Pattern | Decorator Pattern

kc@example.com (kc kim) — Sat, 19 Mar 2022 15:19:00 +0900

What Is the Decorator Pattern?

The English word decorator means to decorate. It strongly implies adding something to existing content.
The Decorator pattern is a way to keep adding decoration to an object.
Using pizza as an example, think of adding toppings on top of an existing pizza.
Just as sponge cake can be decorated with cream, chocolate, strawberries, and so on, objects can also be decorated by wrapping them with features one by one.
In GoF design patterns, it is classified as a structural design pattern.

Decorator Pattern Example Program

This example program decorates an input string with borders and similar elements.

Class Diagram

1. Display Class

This is an abstract class for displaying character lines.

Display.java

package com.devkuma.designpattern.structural.decorator;

public abstract class Display {

    // Return the number of characters in a column.
    public abstract int getColumns();

    // Return the number of rows.
    public abstract int getRows();

    // Return the string for the specified row.
    public abstract String getRowText(int row);

    public void show() {
        for (int i = 0; i < getRows(); i++) {
            System.out.println(getRowText(i));
        }
    }
}

2. StringDisplay Class

This class displays a character line consisting of only one row.

StringDisplay.java

package com.devkuma.designpattern.structural.decorator;

public class StringDisplay extends Display {

    private String string;

    public StringDisplay(String string) {
        this.string = string;
    }

    public int getColumns() {

        return string.getBytes().length;
    }

    public int getRows() {
        return 1;
    }

    public String getRowText(int row) {
        return (row == 0) ? string : null;
    }
}

3. Border Class

This abstract class represents a decorative border.

Border.java

package com.devkuma.designpattern.structural.decorator;

public abstract class Border extends Display {

    protected Display display;

    protected Border(Display display) {
        this.display = display;
    }
}

4. SideBorder Class

This class adds decorative borders on the left and right.

SideBorder.java

package com.devkuma.designpattern.structural.decorator;

public class SideBorder extends Border {

    public SideBorder(Display display) {
        super(display);
    }

    public int getColumns() {
        // The number of characters is the content plus decorative characters on both sides.
        return 1 + display.getColumns() + 1;
    }

    public int getRows() {
        // The number of rows is the same as the content.
        return display.getRows();
    }

    public String getRowText(int row) {
        return "*" + display.getRowText(row) + "*";
    }
}

5. FullBorder Class

This class adds decorative borders on the top, bottom, left, and right.

FullBorder.java

package com.devkuma.designpattern.structural.decorator;

public class FullBorder extends Border {

    public FullBorder(Display display) {
        super(display);
    }

    public int getColumns() {
        // The number of characters is the content plus decorative characters on both sides.
        return 1 + display.getColumns() + 1;
    }

    public int getRows() {
        // The number of rows is the content plus decorative rows above and below.
        return 1 + display.getRows() + 1;
    }

    public String getRowText(int row) {
        if (row == 0) {
            // Top border
            return "+" + makeLine('-', display.getColumns()) + "+";
        } else if (row == display.getRows() + 1) {
            // Bottom border
            return "+" + makeLine('-', display.getColumns()) + "+";
        } else {
            // Other rows
            return "|" + display.getRowText(row - 1) + "|";
        }
    }

    private String makeLine(char ch, int count) {
        StringBuffer buf = new StringBuffer();
        for (int i = 0; i < count; i++) {
            buf.append(ch);
        }
        return buf.toString();
    }
}

6. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.decorator;

public class Main {

    public static void main(String[] args) {
        Display display1 = new StringDisplay("Hello world");
        display1.show();
        System.out.println("");

        Display display2 = new SideBorder(display1);
        display2.show();
        System.out.println("");

        Display display3 = new FullBorder(display2);
        display3.show();
        System.out.println("");

        Display display4 =
                new FullBorder(
                        new SideBorder(
                                new FullBorder(
                                        new StringDisplay("Hello world"))));
        display4.show();
    }
}

7. Execution Result

Hello world

*Hello world*

+-------------+
|*Hello world*|
+-------------+

+---------------+
|*+-----------+*|
|*|Hello world|*|
|*+-----------+*|
+---------------+

Advantages of the Decorator Pattern

In the Decorator pattern, both the decorative border(Border) and the content(StringDisplay) have a common interface. The interface is common, but the more you wrap, the more features are added. At that time, there is no need to modify the object being wrapped. Features can be added without changing what is wrapped.

Design Pattern | Facade Pattern

kc@example.com (kc kim) — Sat, 19 Mar 2022 15:19:00 +0900

What Is the Facade Pattern?

The English word facade means front.
It means the front of a building and refers to a design pattern that provides a simplified interface to another large part of a software codebase.
To perform processing using a large program, many related classes must be controlled appropriately. If a gateway for that processing is prepared, many classes do not need to be controlled individually.
The Facade pattern prepares a simple gateway to a complex system.
A Facade object reduces the dependency of code outside complex software on the internal code of a library and provides a simple interface for using the complex software.
In GoF design patterns, it is classified as a structural design pattern.

Facade Pattern Example Program

This example program creates a user’s web page.

Class Diagram

1. PageMaker Class

This class creates a user’s web page from an email address. This class is the Facade.

PageMaker.java

package com.devkuma.designpattern.structural.facade.pagemaker;

import java.io.FileWriter;
import java.io.IOException;
import java.util.Properties;

public class PageMaker {

    private PageMaker() {}

    public static void makeWelcomePage(String mailaddr, String filename) {
        try {
            Properties mailProp = Database.getProperties("maildata");
            String username = mailProp.getProperty(mailaddr);
            HtmlWriter writer = new HtmlWriter(new FileWriter(filename));
            writer.title("Welcome to " + username + "'s page!");
            writer.paragraph(username + "의 페이지에 어서오세요.");
            writer.paragraph("문의 사항을 메일을 보내주세요.");
            writer.mailto(mailaddr, username);
            writer.close();
            System.out.println(filename + " is created for " + mailaddr + " (" + username + ")");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. HtmlWriter Class

This class writes an HTML file.

HtmlWriter.java

package com.devkuma.designpattern.structural.facade.pagemaker;

import java.io.IOException;
import java.io.Writer;

public class HtmlWriter {

    private Writer writer;

    public HtmlWriter(Writer writer) {
        this.writer = writer;
    }

    public void title(String title) throws IOException {
        writer.write("<html>");
        writer.write("<head>");
        writer.write("<title>" + title + "</title>");
        writer.write("</head>");
        writer.write("<body>\n");
        writer.write("<h1>" + title + "</h1>\n");
    }

    public void paragraph(String msg) throws IOException {
        writer.write("<p>" + msg + "</p>\n");
    }

    public void link(String href, String caption) throws IOException {
        paragraph("<a href=\"" + href + "\">" + caption + "</a>");
    }

    public void mailto(String mailaddr, String username) throws IOException {
        link("mailto:" + mailaddr, username);
    }

    public void close() throws IOException {
        writer.write("</body>");
        writer.write("</html>\n");
        writer.close();
    }
}

3. Database Class

This class obtains a username from an email address.

Database.java

package com.devkuma.designpattern.structural.facade.pagemaker;

import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;

public class Database {

    private Database() {
    }

    public static Properties getProperties(String dbname) {
        ClassLoader loader = Database.class.getClassLoader();
        String file = loader.getResource("facade/pagemaker/" + dbname + ".txt").getFile();
        Properties prop = new Properties();
        try {
            prop.load(new FileInputStream(file));
        } catch (IOException e) {
            System.out.println("Warning: " + file + " is not found.");
        }
        return prop;
    }
}

4. maildata Database

This is a database file.

maildata.txt

devkuma@devkuma.com=dekuma
ariakuma@devkuma.com=ariakuma
kimkc@devkuma.com=kim

5. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.facade;

import com.devkuma.designpattern.structural.facade.pagemaker.PageMaker;

public class Main {
    public static void main(String[] args) {
        PageMaker.makeWelcomePage("devkuma@devkuma.com", "welcome.html");
    }
}

6. Execution Result

<html><head><title>Welcome to devkuma's page!</title></head><body>
<h1>Welcome to devkuma's page!</h1>
<p>devkuma의 페이지에 어서오세요.</p>
<p>문의 사항을 메일을 보내주세요.</p>
<p><a href="mailto:devkuma@devkuma.com">devkuma</a></p>
</body></html>

Advantages of the Facade Pattern

When there are many classes or methods, programmers may be unsure which one to use or must pay attention to call order. The need to pay attention means mistakes become more likely.
Using the Facade pattern reduces the interface and presents complex things simply.
Having fewer interfaces can also be described as looser coupling with the outside. In other words, it creates loose coupling and makes packages easier to reuse as components.

Design Pattern | Flyweight Pattern

kc@example.com (kc kim) — Sat, 19 Mar 2022 16:31:00 +0900

What Is the Flyweight Pattern?

The English word flyweight means “flyweight”, the lightest weight class in boxing.
In the Flyweight pattern, weight refers to memory usage.
The Flyweight pattern reduces memory usage by sharing instances as much as possible.
In GoF design patterns, it is classified as a structural design pattern.

Flyweight Pattern Example Program

This program reads large-character text from files and displays it.

Class Diagram

1. BigChar Class

This class represents a large character.

BigChar.java

package com.devkuma.designpattern.structural.flyweight;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BigChar {

    // String representing a large character, composed of '#', '.', and '\n'.
    private String fontData;

    public BigChar(char charName) {
        try {
            ClassLoader loader = BigChar.class.getClassLoader();
            String file = loader.getResource("flyweight/big" + charName + ".txt").getFile();
            BufferedReader reader = new BufferedReader(new FileReader(file));
            String line;
            StringBuffer buf = new StringBuffer();
            while ((line = reader.readLine()) != null) {
                buf.append(line);
                buf.append("\n");
            }
            reader.close();
            this.fontData = buf.toString();
        } catch (IOException e) {
            this.fontData = charName + "?";
        }
    }

    // Displays the large character.
    public void print() {
        System.out.print(fontData);
    }
}

2. BigCharFactory Class

This class creates BigChar instances while sharing them.

BigCharFactory.java

package com.devkuma.designpattern.structural.flyweight;

import java.util.HashMap;

public class BigCharFactory {

    // Manage already created BigChar instances.
    private HashMap pool = new HashMap();

    private static BigCharFactory singleton = new BigCharFactory();

    private BigCharFactory() {
    }

    // Return the only instance.
    public static BigCharFactory getInstance() {
        return singleton;
    }

    // Create a BigChar instance(shared).
    public synchronized BigChar getBigChar(char charName) {
        BigChar bigChar = (BigChar) pool.get("" + charName);
        if (bigChar == null) {
            bigChar = new BigChar(charName);
            pool.put("" + charName, bigChar);
        }
        return bigChar;
    }
}

3. BigString Class

This class represents a “large string” made by collecting BigChar objects.

BigString.java

package com.devkuma.designpattern.structural.flyweight;

public class BigString {

    private BigChar[] bigChars;

    public BigString(String string) {
        bigChars = new BigChar[string.length()];
        BigCharFactory factory = BigCharFactory.getInstance();
        for (int i = 0; i < bigChars.length; i++) {
            bigChars[i] = factory.getBigChar(string.charAt(i));
        }
    }

    public void print() {
        for (int i = 0; i < bigChars.length; i++) {
            bigChars[i].print();
        }
    }
}

4. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.flyweight;

public class Main {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage: java Main digits");
            System.out.println("Example: java Main 1234");
            System.exit(0);
        }
        BigString bs = new BigString(args[0]);
        bs.print();
    }
}

5. Data

Refer to the txt files below.
/java-design-pattern-tutorial/src/resources/com/devkuma/designpattern/flyweight

6. Execution Result

The result below is produced by running the program with 0329 as the argument.

....######......
..##......##....
..##......##....
..##......##....
..##......##....
..##......##....
....######......
................
....######......
..##......##....
..........##....
......####......
..........##....
..##......##....
....######......
................
....######......
..##......##....
..........##....
......####......
....##..........
..##............
..##########....
................
....######......
..##......##....
..##......##....
....########....
..........##....
..##......##....
....######......
................

Advantages of the Flyweight Pattern

When instances are shared, there is no need to call new every time, so memory usage is lower. More generally, sharing instances can reduce the amount of resources needed to create instances. Resources are computer resources, and memory is one type of resource.
Time is also a type of resource. If creating an instance with new takes a certain amount of time each time, using the Flyweight pattern to share instances can reduce the number of times instances are created with new. This can improve program speed.

Design Pattern | Proxy Pattern

kc@example.com (kc kim) — Sat, 19 Mar 2022 15:19:00 +0900

What Is the Proxy Pattern?

The English word proxy means agent or representative.
It is a method that substitutes for an existing element.
In object orientation, both “the object itself” and “the proxy” are objects.
The Proxy pattern is a way for a proxy object to perform part of the work on behalf of an object that is too busy or cannot work directly.
What matters in the Proxy pattern is that it should only control the flow and must not manipulate or change the result value.
A proxy is used to access an object.
In GoF design patterns, it is classified as a structural design pattern.

Proxy Pattern Example Program

This is an example program of a “named printer” that displays text on the screen.

Class Diagram

1. Printable Interface

This is the common interface for Printer and PrinterProxy.

Printable.java

package com.devkuma.designpattern.structural.proxy;

public interface Printable {
    // Set name
    void setPrinterName(String name);

    // Return name
    String getPrinterName();

    // Display string(print out)
    void print(String string);
}

2. Printer Class

This class represents a named printer. It is the real object.

Printer.java

package com.devkuma.designpattern.structural.proxy;

public class Printer implements Printable {

    private String name;

    public Printer() {
        heavyJob("Printer의 인스턴스를 생성중");
    }

    public Printer(String name) {
        this.name = name;
        heavyJob("Printer의 인스턴스 (" + name + ")를 생성중");
    }

    public void setPrinterName(String name) {
        this.name = name;
    }

    public String getPrinterName() {
        return name;
    }

    public void print(String string) {
        System.out.println("=== " + name + " ===");
        System.out.println(string);
    }

    private void heavyJob(String msg) {
        System.out.print(msg);
        for (int i = 0; i < 5; i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
            System.out.print(".");
        }
        System.out.println("완료");
    }
}

3. PrinterProxy Class

This class represents a named printer proxy. It is the proxy.

PrinterProxy.java

package com.devkuma.designpattern.structural.proxy;

public class PrinterProxy implements Printable {

    private String name;
    private Printer real;

    public PrinterProxy() {
    }

    public PrinterProxy(String name) {
        this.name = name;
    }

    public synchronized void setPrinterName(String name) {
        if (real != null) {
            real.setPrinterName(name);
        }
        this.name = name;
    }

    public String getPrinterName() {
        return name;
    }

    public void print(String string) {
        realize();
        real.print(string);
    }

    private synchronized void realize() {
        if (real == null) {
            real = new Printer(name);
        }
    }
}

4. Main Class

This is the class that executes the main processing.

Main.java

package com.devkuma.designpattern.structural.proxy;

public class Main {
    public static void main(String[] args) {
        Printable p = new PrinterProxy("Alice");
        System.out.println("현재 이름은 " + p.getPrinterName() + " 입니다.");
        p.setPrinterName("Bob");
        System.out.println("현재 이름은 " + p.getPrinterName() + " 입니다.");
        p.print("Hello, world.");
    }
}

5. Execution Result

현재 이름은 Alice 입니다.
현재 이름은 Bob 입니다.
Printer의 인스턴스 (Bob)를 생성중.....완료
=== Bob ===
Hello, world.

Advantages of the Proxy Pattern

In the Proxy pattern, the Proxy becomes the representative and handles as much processing as possible in place of the real object.
In the example program, by using the Proxy role, heavy processing(instance creation) could be delayed until the moment print is actually called.
For example, in a system with many features that take time to initialize, if every feature is initialized at application startup, including features not used at startup, application startup will take longer.
The lazy behavior could be placed inside the Printer class from the beginning without splitting it into PrinterProxy and Printer. However, by separating the classes, the program becomes more componentized and individual features can be added more easily.

Design Pattern | Chain of Responsibility

kc@example.com (kc kim) — Sat, 19 Mar 2022 21:26:00 +0900

What Is the Chain of Responsibility Pattern?

Chain means a sequence, and Responsibility means responsibility. Chain of Responsibility therefore means a chain of responsibility. In practice, it is often easier to understand as a rotating or passing structure.
The Chain of Responsibility pattern connects several objects in a chain and walks through that chain in order to decide the final object that will handle a request.
If a request comes to someone and that person can handle it, they handle it. If they cannot, they pass the request to the next person. Repeating this process is the Chain of Responsibility pattern.
In GoF design patterns, it is classified as a behavioral design pattern.

Chain of Responsibility Pattern Example Program

The example program resolves an input problem through one of several support objects.

Class Diagram

The main roles are Trouble, which represents a problem, Support, which is the common support class, and concrete support classes such as no-support, limit-based support, odd-number support, and special-number support. Each support object decides whether it can solve the problem; if not, it forwards the problem to the next support object in the chain.

Advantages

This pattern separates the sender of a request from the object that handles it. A request can be passed along the chain until an appropriate handler is found, so handlers can be added, removed, or reordered without changing the requester.

Design Pattern | Command Pattern

kc@example.com (kc kim) — Sat, 19 Mar 2022 21:27:00 +0900

What Is the Command Pattern?

Command means instruction.
The Command pattern represents a command as an instance of a class.
When you want to manage command history, you manage a collection of those instances. By storing commands, the same command can be executed again, or several commands can be combined and reused as a new command.
In GoF design patterns, it is classified as a behavioral design pattern.

Command Pattern Example Program

The example is a simple drawing program.

Class Diagram

The example defines a Command interface with execute(), a history object that stores commands, drawable targets, drawing commands, and UI classes that create and replay drawing operations. Each drawing action is captured as an object, so it can be executed, stored, replayed, or grouped.

Advantages

Commands can be treated as data. This makes it easier to implement histories, undo/redo, macro commands, queues, logging, and delayed execution while keeping the requester independent from the actual receiver.

Design Pattern | Interpreter Pattern

kc@example.com (kc kim) — Sat, 19 Mar 2022 21:29:00 +0900

What Is the Interpreter Pattern?

Interpreter means translator or interpreter.
The Interpreter pattern interprets and represents the contents of a file written in a certain format by using a program that plays the role of an interpreter.
In GoF design patterns, it is classified as a behavioral design pattern.

Interpreter Pattern Example Program

This example program parses a language written in a text file.

Class Diagram

The grammar of the language used as the parsing target is written in BNF notation.

<program> ::= program <command list>
<command list> ::= <command>* end
<command> ::= <repeat command> | <primitive command>
<repeat command> ::= repeat <number> <command list>
<primitive command> ::= go | right | left

<program> means that a sequence of commands follows the token program.
<command list> means zero or more commands followed by the token end.
<command> is either a repeat command or a primitive command. | means OR.
<repeat command> represents repeated execution.
<primitive command> represents a basic command such as go, right, or left.

The example separates grammar concepts into node classes such as program, command list, command, repeat command, and primitive command. Each node parses its own grammar rule and builds a syntax tree.

Advantages

When a language or rule set can be expressed as grammar, the Interpreter pattern lets each grammar rule be represented as a class. This makes parsing and extension easier, although it can become verbose if the grammar grows large.

Design Pattern | Iterator Pattern

kc@example.com (kc kim) — Sun, 13 Mar 2022 17:56:00 +0900

What Is the Iterator Pattern?

Iterate means to repeat something. Iterator means one who repeats.
The Iterator pattern is a method for sequentially accessing elements of an aggregate.
In GoF design patterns, it is classified as a behavioral design pattern.

Visitor means visitor.
The Visitor pattern separates data structures from processing.
It prepares visitor classes that traverse a data structure and leaves processing to those visitor classes. When you want to add new processing, you create a new visitor. The data structure only needs to accept the visitor.
In GoF design patterns, it is classified as a behavioral design pattern.

Visitor Pattern Example Program

The example program displays a directory and file list.

Class Diagram

The example defines an Element interface for data structures that accept visitors, a Visitor abstraction, file and directory entries, and a concrete visitor that traverses and prints the structure.

Advantages

Operations can be added by adding new visitors without changing the data structure classes. This is useful when the object structure is stable but the operations performed on it change often.