> For the complete documentation index, see [llms.txt](https://ondrej-kvasnovsky-2.gitbook.io/design-patterns-handbook/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://ondrej-kvasnovsky-2.gitbook.io/design-patterns-handbook/anti-patterns/over-patternized.md).

# Over Patternized

Over patternization happens when we go wild and we use every design pattern we have heard of without applying any reasoning.

## Example - Hello World

Lets say we want to print `Hello World!` message. One, simple approach would be this one. Just print out the message, which should be enough for the first version of the hello world application.

```
class PrintHelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
```

The other approach is to throw there couple of design patterns (BDUF - big design up front). We are going to use `Facade` pattern because amount of classes is too high to expect someone would try to understand what is happening under the hood. `Facade` patter helps us to wrap all the logic. It first creates a message using `Builder` pattern pattern. Then it acquires command factory using `Factory` and `Singleton` patterns. Then we create a new command that will be responsible for printing out the text, `Command` pattern. When we have command pattern, we just call execute which prints out the message.

```
class PrintHelloWorld {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.print("Hello World!");
    }
}

class Facade {
    public void print(String message) {
        Message m = new MessageBuilder().withMessage(message).build();
        CommandFactory commandFactory = SystemOutPrintlnCommandFactory.getInstance();
        Command command = commandFactory.createCommand(m);
        command.execute();
    }
}

interface Message {
    String getMessage();
    void setMessage(String message);
}

class DefaultMessage implements Message {
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

class MessageBuilder {
    private final Message message;

    public MessageBuilder() {
        this.message = new DefaultMessage();
    }

    public MessageBuilder withMessage(String message) {
        this.message.setMessage(message);
        return this;
    }

    public Message build() {
        return message;
    }
}

interface CommandFactory {
    Command createCommand(Message message);
}

class SystemOutPrintlnCommandFactory implements CommandFactory {

    private static SystemOutPrintlnCommandFactory instance = new SystemOutPrintlnCommandFactory();

    public static CommandFactory getInstance() {
        return instance;
    }

    private SystemOutPrintlnCommandFactory() {}

    @Override
    public Command createCommand(Message message) {
        if (message instanceof DefaultMessage) {
            return new SystemOutPrintlnCommand(message);
        }
        throw new RuntimeException("No suitable command found");
    }
}

interface Command {
    void execute();
}

class SystemOutPrintlnCommand implements Command {

    private Message message;

    public SystemOutPrintlnCommand(Message message) {
        this.message = message;
    }

    @Override
    public void execute() {
        System.out.println(message.getMessage());
    }
}
```